@authup/client-web-kit
Version:
This package contains vue components.
1,442 lines • 301 kB
JavaScript
import installFormControl, { VCFormGroup, VCFormInput, VCFormInputCheckbox, VCFormSelect, buildFormGroup, buildFormInput, buildFormInputCheckbox, buildFormInputText, buildFormSelect, buildFormSubmit, buildFormTextarea } from "@vuecs/form-controls";
import { installStoreManager } from "@vuecs/form-controls/core";
import installPagination, { buildPagination } from "@vuecs/pagination";
import { EntityDefaultEventName, EntityType, IdentityProviderPreset, IdentityProviderProtocol, REALM_MASTER_NAME, buildEntityChannelName, buildUserFakeEmail, getIdentityProviderProtocolForPreset, isUserFakeEmail } from "@authup/core-kit";
import { Fragment, Suspense, Teleport, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createSlots, createTextVNode, createVNode, defineComponent, getCurrentInstance, guardReactiveProps, h, hasInjectionContext, inject as inject$1, isReactive, isRef, mergeProps, nextTick, normalizeClass, normalizeProps, onMounted, onUnmounted, openBlock, provide as provide$1, reactive, ref, renderList, renderSlot, resolveComponent, resolveDynamicComponent, toDisplayString, toRaw, toRef, unref, watch, withCtx, withModifiers } from "vue";
import { IVuelidate, getSeverity, install as install$1, useTranslationsForBaseValidation as useTranslationsForBaseValidation$1, useTranslationsForNestedValidations } from "@ilingo/vuelidate";
import useVuelidate from "@vuelidate/core";
import { email, helpers, maxLength, maxValue, minLength, minValue, numeric, required, sameAs, url } from "@vuelidate/validators";
import { SlotName, buildList } from "@vuecs/list-controls";
import { Client, ClientAuthenticationHook, ClientAuthenticationHookEventName, CookieName } from "@authup/core-http-kit";
import { defineStore, storeToRefs as storeToRefs$1 } from "pinia";
import { BuiltInPolicyType, PermissionEvaluator, PermissionMemoryProvider, PolicyData, PolicyEngine, TimePolicyInterval, isIntervalForDayOfMonth, isIntervalForDayOfWeek, isIntervalForDayOfYear } from "@authup/access";
import { OAuth2Error, deserializeOAuth2Scope, isOpenIDProviderMetadata } from "@authup/specs";
import { useCookies } from "@vueuse/integrations/useCookies";
import { injectLocale, useTranslation as useTranslation$1 } from "@ilingo/vuelidate/vue";
import { MemoryStore } from "@ilingo/vuelidate/core";
import { DecisionStrategy, base64URLEncode, createNanoID, extendObject, hasOwnProperty, isBCryptHash, isObject } from "@authup/kit";
import { createMerger, isObject as isObject$1, merge } from "smob";
import { SortDirection } from "rapiq";
import { ClientManager, EventNameSuffix, buildEventFullName } from "@authup/core-realtime-kit";
//#region \0rolldown/runtime.js
var __defProp = Object.defineProperty;
var __exportAll = (all, no_symbols) => {
let target = {};
for (var name in all) __defProp(target, name, {
get: all[name],
enumerable: true
});
if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
return target;
};
//#endregion
//#region src/components/utility/form-input-list/AFormInputListItem.vue?vue&type=script&lang.ts
var AFormInputListItem_vue_vue_type_script_lang_default = defineComponent({
components: {
IVuelidate,
VCFormInput,
VCFormGroup
},
props: {
name: {
type: String,
default: void 0
},
disabled: {
type: Boolean,
default: false
}
},
emits: ["updated", "deleted"],
setup(props, ctx) {
const form = reactive({ name: props.name });
const vuelidate = useVuelidate({ name: {
required,
minLength: minLength(2),
maxLength: maxLength(512)
} }, form);
const handleUpdated = () => {
ctx.emit("updated", vuelidate.value.name.$model);
};
const handleDeleted = () => {
ctx.emit("deleted");
};
return {
handleUpdated,
handleDeleted,
vuelidate
};
}
});
//#endregion
//#region \0plugin-vue:export-helper
var _plugin_vue_export_helper_default = (sfc, props) => {
const target = sfc.__vccOpts || sfc;
for (const [key, val] of props) target[key] = val;
return target;
};
//#endregion
//#region src/components/utility/form-input-list/AFormInputListItem.vue
const _hoisted_1$24 = ["disabled"];
function _sfc_render$53(_ctx, _cache, $props, $setup, $data, $options) {
const _component_VCFormInput = resolveComponent("VCFormInput");
const _component_VCFormGroup = resolveComponent("VCFormGroup");
const _component_IVuelidate = resolveComponent("IVuelidate");
return openBlock(), createBlock(_component_IVuelidate, { validation: _ctx.vuelidate.name }, {
default: withCtx((props) => [createVNode(_component_VCFormGroup, {
"validation-messages": props.data,
"validation-severity": props.severity
}, {
default: withCtx(() => [createVNode(_component_VCFormInput, {
modelValue: _ctx.vuelidate.name.$model,
"onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.vuelidate.name.$model = $event),
onChange: _ctx.handleUpdated
}, {
groupAppend: withCtx(() => [createElementVNode("button", {
disabled: _ctx.disabled,
type: "button",
class: "btn btn-xs btn-warning",
onClick: _cache[0] || (_cache[0] = withModifiers((...args) => _ctx.handleDeleted && _ctx.handleDeleted(...args), ["prevent"]))
}, [..._cache[2] || (_cache[2] = [createElementVNode("i", { class: "fa fa-minus" }, null, -1)])], 8, _hoisted_1$24)]),
_: 1
}, 8, ["modelValue", "onChange"])]),
_: 1
}, 8, ["validation-messages", "validation-severity"])]),
_: 1
}, 8, ["validation"]);
}
var AFormInputListItem_default = /* @__PURE__ */ _plugin_vue_export_helper_default(AFormInputListItem_vue_vue_type_script_lang_default, [["render", _sfc_render$53]]);
//#endregion
//#region src/core/inject.ts
function inject(key, instance) {
if (instance && instance._context && instance._context.provides && instance._context.provides[key]) return instance._context.provides[key];
if (hasInjectionContext()) return inject$1(key, void 0);
}
//#endregion
//#region src/core/provide.ts
function provide(key, value, app) {
if (typeof app === "undefined") {
if (typeof inject(key) !== "undefined") return;
provide$1(key, value);
return;
}
if (app && app._context && app._context.provides && app._context.provides[key]) return;
app.provide(key, value);
}
//#endregion
//#region src/core/http-client/authentication-hook/singleton.ts
const sym$2 = Symbol.for("AuthupHTTPClientAuthenticationHook");
function injectHTTPClientAuthenticationHook(app) {
const instance = inject(sym$2, app);
if (!instance) throw new Error("The http client authentication hook has not been injected in the app context.");
return instance;
}
function hasHTTPClientAuthenticationHook(app) {
try {
return !!injectHTTPClientAuthenticationHook(app);
} catch {
return false;
}
}
function provideHTTPClientAuthenticationHook(refresher, app) {
provide(sym$2, refresher, app);
}
//#endregion
//#region src/core/store/constants.ts
const STORE_ID = "authup";
//#endregion
//#region src/core/store/dispatcher/constants.ts
let StoreDispatcherEventName = /* @__PURE__ */ function(StoreDispatcherEventName) {
StoreDispatcherEventName["LOGGING_IN"] = "loggingIn";
StoreDispatcherEventName["LOGGED_IN"] = "loggedIn";
StoreDispatcherEventName["LOGGING_OUT"] = "loggingOut";
StoreDispatcherEventName["LOGGED_OUT"] = "loggedOut";
StoreDispatcherEventName["RESOLVING"] = "resolving";
StoreDispatcherEventName["RESOLVED"] = "resolved";
StoreDispatcherEventName["ACCESS_TOKEN_UPDATED"] = "accessTokenUpdated";
StoreDispatcherEventName["ACCESS_TOKEN_EXPIRE_DATE_UPDATED"] = "accessTokenExpireDateUpdated";
StoreDispatcherEventName["REFRESH_TOKEN_UPDATED"] = "refreshTokenUpdated";
StoreDispatcherEventName["USER_UPDATED"] = "userUpdated";
StoreDispatcherEventName["REALM_UPDATED"] = "realmUpdated";
StoreDispatcherEventName["REALM_MANAGEMENT_UPDATED"] = "realmManagementUpdated";
return StoreDispatcherEventName;
}({});
//#endregion
//#region ../../node_modules/@posva/event-emitter/dist/index.js
var EventEmitter = class {
/**
* A Map of event names to registered handler functions.
*/
all;
constructor(all) {
this.all = all || /* @__PURE__ */ new Map();
}
on(type, handler) {
if (!this.all.has(type)) this.all.set(type, []);
const handlers = this.all.get(type);
handlers.push(handler);
return () => handlers.splice(handlers.indexOf(handler) >>> 0, 1);
}
off(type, handler) {
if (!type) return this.all.clear();
const handlers = this.all.get(type);
if (handlers) if (handler) handlers.splice(handlers.indexOf(handler) >>> 0, 1);
else this.all.delete(type);
}
/**
* Invoke all handlers for the given type.
* If present, `'*'` handlers are invoked after type-matched handlers.
*
* Note: Manually firing `'*'` handlers is not supported.
*
* @param type The event type to invoke
* @param payload Any value to each handler
*/
emit(type, ...payload) {
let handlers = this.all.get(type);
handlers?.slice().map((handler) => {
handler(...payload);
});
handlers = this.all.get("*");
if (handlers) handlers.slice().map((handler) => {
handler(type, payload);
});
}
};
//#endregion
//#region src/core/store/dispatcher/module.ts
function createStoreDispatcher() {
return new EventEmitter();
}
//#endregion
//#region src/core/store/dispatcher/singleton.ts
const sym$1 = Symbol.for("AuthupStoreEventBus");
function injectStoreDispatcher(app) {
const instance = inject(sym$1, app);
if (!instance) throw new Error("The store dispatcher has not been injected in the app context.");
return instance;
}
function provideStoreDispatcher(eventBus, app) {
provide(sym$1, eventBus, app);
}
//#endregion
//#region src/core/store/create.ts
function createPromiseShareWrapperFn(fn) {
let promise;
return (...args) => {
if (promise) return promise;
promise = new Promise((resolve, reject) => {
fn(...args).then((r) => resolve(r)).catch((e) => reject(e));
});
promise.finally(() => {
setTimeout(() => {
promise = void 0;
}, 0);
});
return promise;
};
}
function createStore(context) {
const client = new Client({ baseURL: context.baseURL });
const cookiesRead = ref(false);
const setCookiesRead = (value) => {
cookiesRead.value = value;
};
const accessToken = ref(null);
const setAccessToken = (input) => {
accessToken.value = input;
context.dispatcher.emit("accessTokenUpdated", input);
};
const accessTokenExpireDate = ref(null);
const setAccessTokenExpireDate = (input) => {
if (typeof input === "number" || typeof input === "string") accessTokenExpireDate.value = new Date(input);
else accessTokenExpireDate.value = input;
context.dispatcher.emit("accessTokenExpireDateUpdated", accessTokenExpireDate.value);
};
const refreshToken = ref(null);
const setRefreshToken = (input) => {
refreshToken.value = input;
context.dispatcher.emit("refreshTokenUpdated", input);
};
const user = ref(null);
const userId = computed(() => user.value ? user.value.id : null);
const setUser = (input) => {
user.value = input;
context.dispatcher.emit("userUpdated", input);
};
const realm = ref(null);
const realmId = computed(() => realm.value ? realm.value.id : void 0);
const realmName = computed(() => realm.value ? realm.value.name : void 0);
const realmIsRoot = computed(() => {
if (realm.value) return realm.value.name === REALM_MASTER_NAME;
return false;
});
const setRealm = (input) => {
realm.value = input;
context.dispatcher.emit("realmUpdated", input);
};
const realmManagement = ref(null);
const realmManagementId = computed(() => realmManagement.value ? realmManagement.value.id : realmId.value);
const realmManagementName = computed(() => realmManagement.value ? realmManagement.value.name : realmName.value);
const setRealmManagement = (input) => {
realmManagement.value = input;
context.dispatcher.emit("realmManagementUpdated", input);
};
const permissionProvider = new PermissionMemoryProvider();
const permissionEvaluator = new PermissionEvaluator({
provider: permissionProvider,
policyEngine: new PolicyEngine()
});
const cleanup = async () => {
const tempAccessToken = accessToken.value;
const tempRefreshToken = refreshToken.value;
setAccessToken(null);
setAccessTokenExpireDate(null);
setRefreshToken(null);
setUser(null);
setRealm(null);
setRealmManagement(null);
permissionProvider.setMany([]);
tokenResolved.value = false;
userResolved.value = false;
try {
if (tempAccessToken) await client.token.revoke({ token: tempAccessToken });
} catch {}
try {
if (tempRefreshToken) await client.token.revoke({ token: tempRefreshToken });
} catch {}
};
const userResolved = ref(false);
const resolveUser = async () => {
if (!accessToken.value || userResolved.value) return Promise.resolve();
userResolved.value = true;
return client.userInfo.get(`Bearer ${accessToken.value}`).then((response) => {
setUser(response);
});
};
const tokenResolved = ref(false);
const resolveToken = async () => {
if (!accessToken.value || tokenResolved.value) return Promise.resolve();
tokenResolved.value = true;
return client.token.introspect({ token: accessToken.value }, { authorizationHeader: {
type: "Bearer",
token: accessToken.value
} }).then((response) => {
if (response.exp) setAccessTokenExpireDate(/* @__PURE__ */ new Date(response.exp * 1e3));
if (response.realm_id && response.realm_name) {
realm.value = {
id: response.realm_id,
name: response.realm_name
};
if (!realmManagement.value) setRealmManagement(realm.value);
}
if (response.permissions) permissionProvider.setMany(response.permissions.map((permission) => ({ permission: {
name: permission.name,
realm_id: permission.realm_id,
client_id: permission.client_id
} })));
});
};
const applyTokenGrantResponse = (response) => {
setAccessTokenExpireDate(new Date(Date.now() + response.expires_in * 1e3));
setAccessToken(response.access_token);
if (response.refresh_token) setRefreshToken(response.refresh_token);
else setRefreshToken(null);
};
const refreshSession = createPromiseShareWrapperFn(async () => {
if (!refreshToken.value) throw new OAuth2Error("The access token can not be renewed.");
try {
applyTokenGrantResponse(await client.token.createWithRefreshToken({ refresh_token: refreshToken.value }));
} catch (e) {
await cleanup();
throw e;
} finally {
tokenResolved.value = false;
userResolved.value = false;
}
});
const resolveInternal = async () => {
context.dispatcher.emit("resolving");
try {
if (!accessToken.value && refreshToken.value) await refreshSession();
if (accessToken.value) {
await resolveToken();
if (!user.value) await resolveUser();
}
} catch (e) {
if (refreshToken.value) {
await refreshSession();
await resolveToken();
await resolveUser();
} else throw e;
}
context.dispatcher.emit("resolved");
};
const resolve = createPromiseShareWrapperFn(resolveInternal);
const loggedIn = computed(() => !!accessToken.value);
const login = async (ctx) => {
context.dispatcher.emit("loggingIn");
applyTokenGrantResponse(await client.token.createWithPassword({
username: ctx.name,
password: ctx.password,
...realmId.value ? { realm_id: ctx.realmId } : {}
}));
await resolveToken();
await resolveUser();
context.dispatcher.emit("loggedIn");
};
const exchangeAuthorizationCode = async (code) => {
const response = await client.token.createWithAuthorizationCode({ code });
await cleanup();
applyTokenGrantResponse(response);
await resolveToken();
await resolveUser();
};
const logout = async () => {
context.dispatcher.emit("loggingOut");
await cleanup();
context.dispatcher.emit("loggedOut");
};
return {
cookiesRead,
setCookiesRead,
permissionEvaluator,
login,
logout,
loggedIn,
resolve,
exchangeAuthorizationCode,
applyTokenGrantResponse,
accessToken,
setAccessToken,
accessTokenExpireDate,
setAccessTokenExpireDate,
refreshToken,
setRefreshToken,
realm,
realmId,
realmIsRoot,
realmName,
setRealm,
realmManagement,
realmManagementId,
realmManagementName,
setRealmManagement,
user,
userId,
setUser
};
}
//#endregion
//#region src/core/store/singleton.ts
const sym = Symbol.for("AuthupStore");
function injectStore(pinia, app) {
const instance = injectStoreFactory(app);
if (!instance) throw new Error("The store has not been injected in the app context.");
return instance(pinia);
}
function injectStoreFactory(app) {
const instance = inject(sym, app);
if (!instance) throw new Error("The store factory has not been injected in the app context.");
return instance;
}
function hasStoreFactory(app) {
return !!inject(sym, app);
}
function provideStoreFactory(store, app) {
provide(sym, store, app);
}
//#endregion
//#region src/core/store/install.ts
function installStore(app, options = {}) {
if (hasStoreFactory(app)) return;
const storeDispatcher = createStoreDispatcher();
provideStoreDispatcher(storeDispatcher, app);
const storeFactory = defineStore(STORE_ID, () => createStore({
baseURL: options.baseURL,
dispatcher: storeDispatcher
}));
const store = storeFactory(options.pinia);
let cookieGet;
if (options.cookieGet) cookieGet = options.cookieGet;
else cookieGet = useCookies().get;
let cookieSet;
if (options.cookieSet) cookieSet = options.cookieSet;
else cookieSet = useCookies().set;
let cookieUnset;
if (options.cookieUnset) cookieUnset = options.cookieUnset;
else if (options.cookieSet) cookieUnset = (key, opts) => {
options.cookieSet(key, null, opts);
};
else cookieUnset = useCookies().remove;
const readCookies = () => {
if (store.cookiesRead) return;
store.setCookiesRead(true);
const keys = Object.values(CookieName);
let value;
for (const key of keys) {
value = cookieGet(key);
if (!value) continue;
switch (key) {
case CookieName.ACCESS_TOKEN:
if (!store.accessToken) store.setAccessToken(value);
break;
case CookieName.ACCESS_TOKEN_EXPIRE_DATE:
if (!store.accessTokenExpireDate) store.setAccessTokenExpireDate(value);
break;
case CookieName.REFRESH_TOKEN:
if (!store.refreshToken) store.setRefreshToken(value);
break;
case CookieName.USER:
if (!store.user) store.setUser(value);
break;
case CookieName.REALM:
if (!store.realm) store.setRealm(value);
break;
case CookieName.REALM_MANAGEMENT:
if (!store.realmManagement) store.setRealmManagement(value);
break;
}
}
};
const maxAgeFn = () => {
if (!store.accessTokenExpireDate) return;
return Math.floor(Math.max(1e3, (/* @__PURE__ */ new Date(`${store.accessTokenExpireDate}`)).getTime() - Date.now()) / 1e3);
};
storeDispatcher.on("accessTokenExpireDateUpdated", (input) => {
if (input) cookieSet(CookieName.ACCESS_TOKEN_EXPIRE_DATE, input, { maxAge: maxAgeFn() });
else cookieUnset(CookieName.ACCESS_TOKEN_EXPIRE_DATE, {});
});
storeDispatcher.on("accessTokenUpdated", (input) => {
if (input) {
const maxAge = maxAgeFn();
cookieSet(CookieName.ACCESS_TOKEN, input, { maxAge });
} else cookieUnset(CookieName.ACCESS_TOKEN, {});
});
storeDispatcher.on("refreshTokenUpdated", (input) => {
if (input) cookieSet(CookieName.REFRESH_TOKEN, input, {});
else cookieUnset(CookieName.REFRESH_TOKEN, {});
});
storeDispatcher.on("userUpdated", (input) => {
if (input) cookieSet(CookieName.USER, input, {});
else cookieUnset(CookieName.USER, {});
});
storeDispatcher.on("realmUpdated", (input) => {
if (input) cookieSet(CookieName.REALM, input, {});
else cookieUnset(CookieName.REALM, {});
});
storeDispatcher.on("realmManagementUpdated", (input) => {
if (input) cookieSet(CookieName.REALM_MANAGEMENT, input, {});
else cookieUnset(CookieName.REALM_MANAGEMENT, {});
});
readCookies();
provideStoreFactory(storeFactory, app);
}
//#endregion
//#region src/core/store/utils.ts
function storeToRefs(store) {
store = toRaw(store);
const refs = {};
const keys = Object.keys(store);
for (const key of keys) {
const value = store[key];
if (isRef(value) || isReactive(value)) refs[key] = toRef(store, key);
}
return refs;
}
//#endregion
//#region src/core/http-client/authentication-hook/install.ts
function installHTTPClientAuthenticationHook(app, options = {}) {
if (hasHTTPClientAuthenticationHook(app)) return;
const store = injectStoreFactory(app)(options.pinia);
const { refreshToken } = storeToRefs$1(store);
const hook = new ClientAuthenticationHook({
baseURL: options.baseURL,
tokenCreator: () => {
if (!refreshToken.value) throw new Error("No refresh token available.");
return new Client({ baseURL: options.baseURL }).token.createWithRefreshToken({ refresh_token: refreshToken.value });
},
timer: !options.isServer
});
hook.on(ClientAuthenticationHookEventName.REFRESH_FINISHED, (response) => {
store.applyTokenGrantResponse(response);
});
let isSelfCallee = false;
hook.on(ClientAuthenticationHookEventName.HEADER_UNSET, () => {
if (!isSelfCallee) Promise.resolve().then(() => store.logout());
});
const storeDispatcher = injectStoreDispatcher(app);
const handleAccessTokenEvent = () => {
isSelfCallee = true;
if (store.accessToken) {
hook.enable();
hook.setAuthorizationHeader({
type: "Bearer",
token: store.accessToken
});
} else {
hook.disable();
hook.unsetAuthorizationHeader();
}
isSelfCallee = false;
};
const handleAccessTokenExpireDateEvent = () => {
if (store.accessTokenExpireDate) {
const expiresIn = Math.floor((store.accessTokenExpireDate.getTime() - Date.now()) / 1e3);
hook.setTimer(expiresIn);
}
};
storeDispatcher.on("accessTokenUpdated", () => handleAccessTokenEvent());
storeDispatcher.on("accessTokenExpireDateUpdated", () => handleAccessTokenExpireDateEvent());
handleAccessTokenEvent();
handleAccessTokenExpireDateEvent();
provideHTTPClientAuthenticationHook(hook, app);
}
//#endregion
//#region src/core/http-client/singleton.ts
const HTTPClientSymbol = Symbol.for("AuthupHTTPClient");
function provideHTTPClient(client, app) {
provide(HTTPClientSymbol, client, app);
}
function hasHTTPClient(app) {
try {
return !!injectHTTPClient(app);
} catch {
return false;
}
}
function injectHTTPClient(app) {
const instance = inject(HTTPClientSymbol, app);
if (!instance) throw new Error("The api client has not been injected.");
return instance;
}
//#endregion
//#region src/core/http-client/install.ts
function installHTTPClient(app, options = {}) {
if (hasHTTPClient(app)) return;
const client = new Client({ baseURL: options.baseURL });
injectHTTPClientAuthenticationHook(app).attach(client);
provideHTTPClient(client, app);
}
//#endregion
//#region src/core/form/properties.ts
/**
* Assign properties from input to src.
* 'null' values will be transformed to an empty string.
*
* @param src
* @param input
*/
function assignFormProperties(src, input = {}) {
const keys = Object.keys(input);
for (const key of keys) {
const value = input[key];
if (value === null) src[key] = "";
else src[key] = value;
}
return src;
}
//#endregion
//#region src/core/translator/constants.ts
let TranslatorTranslationGroup = /* @__PURE__ */ function(TranslatorTranslationGroup) {
TranslatorTranslationGroup["DEFAULT"] = "default";
TranslatorTranslationGroup["CLIENT"] = "authupClient";
TranslatorTranslationGroup["VUECS"] = "vuecs";
TranslatorTranslationGroup["VUELIDATE"] = "vuelidate";
return TranslatorTranslationGroup;
}({});
let TranslatorTranslationVuecsKey = /* @__PURE__ */ function(TranslatorTranslationVuecsKey) {
TranslatorTranslationVuecsKey["NO_MORE"] = "noMore";
return TranslatorTranslationVuecsKey;
}({});
let TranslatorTranslationClientKey = /* @__PURE__ */ function(TranslatorTranslationClientKey) {
TranslatorTranslationClientKey["NAME_HINT"] = "nameHint";
TranslatorTranslationClientKey["DESCRIPTION_HINT"] = "descriptionHint";
TranslatorTranslationClientKey["REDIRECT_URI_HINT"] = "redirectURIHint";
TranslatorTranslationClientKey["IS_CONFIDENTIAL"] = "isConfidential";
TranslatorTranslationClientKey["IS_ACTIVE"] = "isActive";
TranslatorTranslationClientKey["HASH_SECRET"] = "hashSecret";
return TranslatorTranslationClientKey;
}({});
let TranslatorTranslationDefaultKey = /* @__PURE__ */ function(TranslatorTranslationDefaultKey) {
TranslatorTranslationDefaultKey["ADD"] = "add";
TranslatorTranslationDefaultKey["CREATE"] = "create";
TranslatorTranslationDefaultKey["DELETE"] = "delete";
TranslatorTranslationDefaultKey["GENERATE"] = "generate";
TranslatorTranslationDefaultKey["UPDATE"] = "update";
TranslatorTranslationDefaultKey["ACTIVE"] = "active";
TranslatorTranslationDefaultKey["INACTIVE"] = "inactive";
TranslatorTranslationDefaultKey["LOCKED"] = "locked";
TranslatorTranslationDefaultKey["NOT_LOCKED"] = "notLocked";
TranslatorTranslationDefaultKey["VALUE_IS_REGEX"] = "valueIsRegex";
TranslatorTranslationDefaultKey["CLIENT"] = "client";
TranslatorTranslationDefaultKey["CLIENTS"] = "clients";
TranslatorTranslationDefaultKey["CLIENT_SCOPES"] = "clientScopes";
TranslatorTranslationDefaultKey["DISPLAY_NAME"] = "displayName";
TranslatorTranslationDefaultKey["EMAIL"] = "email";
TranslatorTranslationDefaultKey["EXTERNAL_ID"] = "externalId";
TranslatorTranslationDefaultKey["HASHED"] = "hashed";
TranslatorTranslationDefaultKey["OVERVIEW"] = "overview";
TranslatorTranslationDefaultKey["IDENTITY_PROVIDERS"] = "identityProviders";
TranslatorTranslationDefaultKey["NAME"] = "name";
TranslatorTranslationDefaultKey["DECISION_STRATEGY"] = "decisionStrategy";
TranslatorTranslationDefaultKey["DESCRIPTION"] = "description";
TranslatorTranslationDefaultKey["PERMISSIONS"] = "permissions";
TranslatorTranslationDefaultKey["POLICY"] = "policy";
TranslatorTranslationDefaultKey["POLICIES"] = "policies";
TranslatorTranslationDefaultKey["REALM"] = "realm";
TranslatorTranslationDefaultKey["ROBOTS"] = "robots";
TranslatorTranslationDefaultKey["REALMS"] = "realms";
TranslatorTranslationDefaultKey["ROLES"] = "roles";
TranslatorTranslationDefaultKey["SCOPES"] = "scopes";
TranslatorTranslationDefaultKey["SECRET"] = "secret";
TranslatorTranslationDefaultKey["REDIRECT_URIS"] = "redirectUris";
TranslatorTranslationDefaultKey["USERS"] = "users";
return TranslatorTranslationDefaultKey;
}({});
//#endregion
//#region src/core/translator/singleton.ts
function injectTranslatorLocale() {
return injectLocale();
}
function useTranslation(input) {
return useTranslation$1(input);
}
function useTranslationsForBaseValidation(result) {
return useTranslationsForBaseValidation$1(result);
}
function useTranslationsForNestedValidation(validation) {
return useTranslationsForNestedValidations(validation);
}
//#endregion
//#region src/core/translator/helpers.ts
function useTranslationsForGroup(group, elements) {
const output = {};
for (const element of elements) output[element.key] = useTranslation({
...element,
group
});
return output;
}
//#endregion
//#region src/core/translator/de/client.ts
const TranslatorTranslationClientGerman = {
["nameHint"]: "Etwas, das Benutzer erkennen und vertrauen werden",
["descriptionHint"]: "Dies wird allen Benutzern dieser Anwendung angezeigt",
["redirectURIHint"]: "URI-Muster, zu dem ein Browser nach einem erfolgreichen Login weiterleiten kann",
["isConfidential"]: "Ist vertraulich?",
["isActive"]: "Ist aktiv?",
["hashSecret"]: "Geheimnis hashen?"
};
//#endregion
//#region src/core/translator/de/default.ts
const TranslatorTranslationDefaultGerman = {
["add"]: "hinzufügen",
["create"]: "erstellen",
["delete"]: "löschen",
["generate"]: "generieren",
["update"]: "aktualisieren",
["active"]: "aktiv",
["inactive"]: "inaktiv",
["locked"]: "gesperrt",
["notLocked"]: "nicht gesperrt",
["valueIsRegex"]: "Wert ist regex pattern?",
["client"]: "Client",
["clients"]: "Clients",
["clientScopes"]: "Client-Bereiche",
["displayName"]: "Anzeigename",
["email"]: "E-Mail",
["externalId"]: "externe ID",
["hashed"]: "gehasht",
["overview"]: "Überblick",
["identityProviders"]: "Identitätsanbieter",
["name"]: "Name",
["decisionStrategy"]: "Entscheidungsstrategie",
["description"]: "Beschreibung",
["permissions"]: "Berechtigungen",
["policy"]: "Richtlinie",
["policies"]: "Richtlinien",
["realm"]: "Organisation",
["realms"]: "Organisationen",
["roles"]: "Rollen",
["scopes"]: "Bereiche",
["secret"]: "Geheimnis",
["redirectUris"]: "Weiterleitungs-URIs",
["users"]: "Benutzer"
};
//#endregion
//#region src/core/vuelidate.ts
let VuelidateCustomRuleKey = /* @__PURE__ */ function(VuelidateCustomRuleKey) {
VuelidateCustomRuleKey["ALPHA_NUM_HYPHEN_UNDERSCORE"] = "alphaNumHyphenUnderscore";
VuelidateCustomRuleKey["ALPHA_UPPER_NUM_HYPHEN_UNDERSCORE_DOT"] = "alphaUpperNumHyphenUnderscoreDot";
return VuelidateCustomRuleKey;
}({});
const VuelidateCustomRule = {
["alphaNumHyphenUnderscore"]: helpers.regex(/^[a-z0-9-_]*$/),
["alphaUpperNumHyphenUnderscoreDot"]: helpers.regex(/^[a-z0-9-_.]*$/)
};
function getVuelidateSeverity(vuelidate) {
return getSeverity(vuelidate);
}
function extractVuelidateResultsFromChild(vuelidate, child, keys) {
const childResults = vuelidate.value.$getResultsForChild(child);
if (!childResults) return {};
const childKeys = keys ?? Object.keys(childResults).filter((key) => !key.startsWith("$"));
const result = {};
for (const childKey of childKeys) if (hasOwnProperty(childResults, childKey)) result[childKey] = childResults[childKey].$model;
return result;
}
//#endregion
//#region src/core/translator/de/vuelidate.ts
const TranslatorTranslationVuelidateGerman = {
["alphaNumHyphenUnderscore"]: "Der Eingabewert darf nur aus folgenden Zeichen bestehen: [0-9a-z-_]+",
["alphaUpperNumHyphenUnderscoreDot"]: "Der Eingabewert darf nur aus folgenden Zeichen bestehen: [0-9a-z-_.]+"
};
//#endregion
//#region src/core/translator/de/vuecs.ts
const TranslatorTranslationVuecsGerman = { ["noMore"]: "Keine weiteren {{name}} verfügbar" };
//#endregion
//#region src/core/translator/en/client.ts
const TranslatorTranslationClientEnglish = {
["nameHint"]: "Something users will recognize and trust",
["descriptionHint"]: "Displayed to all users of this application",
["redirectURIHint"]: "URI pattern a browser can redirect to after a successful login",
["isConfidential"]: "Is confidential?",
["isActive"]: "Is active?",
["hashSecret"]: "Hash secret?"
};
//#endregion
//#region src/core/translator/en/default.ts
const TranslatorTranslationDefaultEnglish = {
["add"]: "add",
["create"]: "create",
["delete"]: "delete",
["generate"]: "generate",
["update"]: "update",
["active"]: "active",
["inactive"]: "inactive",
["locked"]: "locked",
["notLocked"]: "not locked",
["valueIsRegex"]: "Value is regex pattern?",
["client"]: "update",
["clients"]: "clients",
["clientScopes"]: "client scopes",
["displayName"]: "display name",
["email"]: "email",
["externalId"]: "external id",
["hashed"]: "hashed",
["overview"]: "overview",
["identityProviders"]: "identity providers",
["name"]: "name",
["decisionStrategy"]: "decision strategy",
["description"]: "description",
["policy"]: "policy",
["policies"]: "policies",
["permissions"]: "permissions",
["realm"]: "realm",
["realms"]: "realms",
["roles"]: "roles",
["scopes"]: "scopes",
["secret"]: "secret",
["redirectUris"]: "redirect uri(s)",
["users"]: "users"
};
//#endregion
//#region src/core/translator/en/vuelidate.ts
const TranslatorTranslationVuelidateEnglish = {
["alphaNumHyphenUnderscore"]: "The input value is only allowed to consist of the following characters: [0-9a-z-_]+",
["alphaUpperNumHyphenUnderscoreDot"]: "The input value is only allowed to consist of the following characters: [0-9a-z-_.]+"
};
//#endregion
//#region src/core/translator/en/vuecs.ts
const TranslatorTranslationVuecsEnglish = { ["noMore"]: "No more {{name}} available" };
//#endregion
//#region src/core/translator/install.ts
function installTranslator(app, options = {}) {
install$1(app, {
store: new MemoryStore({ data: {
de: {
["authupClient"]: TranslatorTranslationClientGerman,
["default"]: TranslatorTranslationDefaultGerman,
["vuecs"]: TranslatorTranslationVuecsGerman,
["vuelidate"]: TranslatorTranslationVuelidateGerman
},
en: {
["authupClient"]: TranslatorTranslationClientEnglish,
["default"]: TranslatorTranslationDefaultEnglish,
["vuecs"]: TranslatorTranslationVuecsEnglish,
["vuelidate"]: TranslatorTranslationVuelidateEnglish
}
} }),
locale: options.locale
});
}
//#endregion
//#region src/core/form/submit.ts
function createFormSubmitTranslations() {
const updateText = useTranslation({
group: "default",
key: "update"
});
return {
createText: useTranslation({
group: "default",
key: "create"
}),
updateText
};
}
function buildFormSubmitWithTranslations(options, translations) {
options.createText = translations.createText.value;
options.updateText = translations.updateText.value;
return buildFormSubmit(options);
}
//#endregion
//#region src/core/query/sort.ts
function isQuerySortedDescByDate(input) {
if (Array.isArray(input)) return input.some((el) => isQuerySortedDescByDate(el));
if (isObject$1(input)) return input.created_at === SortDirection.DESC || input.updated_at === SortDirection.DESC;
return typeof input === "string" && (input === "-created_at" || input === "-updated_at");
}
//#endregion
//#region src/core/busy.ts
function wrapFnWithBusyState(busy, fn) {
return async (...args) => {
if (busy.value) return Promise.resolve();
busy.value = true;
return fn(...args).finally(() => {
busy.value = false;
});
};
}
//#endregion
//#region src/core/permission-check/module.ts
function createPermissionCheckerReactiveFn(ctx = {}) {
let store;
if (ctx.store) store = ctx.store;
else store = injectStore(ctx.pinia, ctx.app);
const storeRefs = storeToRefs(store);
return (ctx) => {
const data = ref(false);
let computePromise;
const compute = async () => {
if (computePromise) return computePromise;
let identity;
if (storeRefs.userId.value) {
identity = {
type: "user",
id: storeRefs.userId.value
};
if (storeRefs.realmId.value) identity.realmId = storeRefs.realmId.value;
if (storeRefs.realmName.value) identity.realmId = storeRefs.realmName.value;
}
let outcome;
const input = ctx.input || new PolicyData();
input.set(BuiltInPolicyType.IDENTITY, identity);
try {
computePromise = store.permissionEvaluator.preEvaluateOneOf({
...ctx,
input
}).then(() => true).catch(() => false);
outcome = await computePromise;
} catch {
outcome = false;
} finally {
computePromise = void 0;
}
return outcome;
};
Promise.resolve().then(() => compute()).then((outcome) => {
data.value = outcome;
});
let removeListener;
onMounted(() => {
removeListener = watch(storeRefs.loggedIn, () => {
Promise.resolve().then(() => compute()).then((outcome) => {
data.value = outcome;
});
});
});
onUnmounted(() => {
if (typeof removeListener !== "undefined") removeListener();
});
return data;
};
}
//#endregion
//#region src/core/socket-manager/singleton.ts
const SocketClientSymbol = Symbol.for("AuthupSocketManager");
function isSocketManagerUsable() {
return !!inject(SocketClientSymbol);
}
function provideSocketManager(manager, app) {
provide(SocketClientSymbol, manager, app);
}
function injectSocketManager(app) {
const manager = inject(SocketClientSymbol, app);
if (!manager) throw new Error("The socket manager has not been injected in the app context.");
return manager;
}
//#endregion
//#region src/core/socket-manager/install.ts
function installSocketManager(app, options) {
const store = injectStoreFactory(app)(options.pinia);
const { accessToken } = storeToRefs(store);
const manager = new ClientManager({
url: options.baseURL,
token: () => accessToken.value ?? void 0
});
const oldValue = ref();
store.$subscribe((mutation, state) => {
const normalizedToken = state.accessToken ?? void 0;
if (normalizedToken !== oldValue.value) {
oldValue.value = normalizedToken;
Promise.resolve().then(() => manager.reconnect());
}
});
provideSocketManager(manager, app);
}
//#endregion
//#region src/core/slot.ts
/**
* Returns true if either scoped or unscoped named slot exists
*
* @returns boolean
*
* @param name
* @param $slots
*/
function hasNormalizedSlot(name, $slots = {}) {
return hasOwnProperty($slots, name);
}
/**
* Returns VNodes for named slot either scoped or unscoped
*
* @param name
* @param scope
* @param $slots
*
* @returns {Array} VNodes
*/
function normalizeSlot(name, scope = {}, $slots = {}) {
if (hasOwnProperty($slots, name)) return $slots[name](scope);
return [];
}
//#endregion
//#region src/components/utility/translation/ATranslationDefault.vue?vue&type=script&lang.ts
var ATranslationDefault_vue_vue_type_script_lang_default = defineComponent({
components: { ATranslation: defineComponent({
props: {
group: {
type: String,
required: true
},
name: {
type: String,
required: true
}
},
setup(props, { slots }) {
const translation = useTranslation({
group: props.group,
key: props.name
});
return () => {
if (hasNormalizedSlot(SlotName.DEFAULT, slots)) return normalizeSlot(SlotName.DEFAULT, { data: translation.value }, slots);
return [translation.value];
};
}
}) },
props: { name: {
type: String,
required: true
} },
setup() {
return { TranslatorTranslationGroup };
}
});
//#endregion
//#region src/components/utility/translation/ATranslationDefault.vue
function _sfc_render$52(_ctx, _cache, $props, $setup, $data, $options) {
const _component_ATranslation = resolveComponent("ATranslation");
return openBlock(), createBlock(_component_ATranslation, {
group: _ctx.TranslatorTranslationGroup.DEFAULT,
name: _ctx.name
}, null, 8, ["group", "name"]);
}
//#endregion
//#region src/components/utility/form-input-list/AFormInputList.vue?vue&type=script&lang.ts
var AFormInputList_vue_vue_type_script_lang_default = defineComponent({
components: {
ATranslationDefault: /* @__PURE__ */ _plugin_vue_export_helper_default(ATranslationDefault_vue_vue_type_script_lang_default, [["render", _sfc_render$52]]),
AFormInputListItem: AFormInputListItem_default
},
props: {
names: {
type: Array,
default: () => []
},
minItems: {
type: Number,
default: 0
},
maxItems: {
type: Number,
default: 100
}
},
emits: ["changed"],
setup(props, setup) {
let counter = 0;
const items = ref([]);
const add = (item) => {
items.value.push({
id: counter++,
value: item || ""
});
};
function assign() {
items.value = [];
props.names.map((el) => add(el));
if (items.value.length < props.minItems) for (let i = 0; i < props.minItems - items.value.length; i++) add();
}
setup.expose({ assign });
assign();
const canAdd = computed(() => items.value.length < props.maxItems);
const canDrop = computed(() => items.value.length > props.minItems);
const emitUpdated = () => {
setup.emit("changed", [...items.value.map((el) => el.value).filter(Boolean)]);
};
const handleUpdated = (id, value) => {
const index = items.value.findIndex((el) => el.id === id);
if (index > -1 && items.value[index]) items.value[index].value = value;
emitUpdated();
};
const handleDeleted = (id) => {
if (items.value.length <= props.minItems) return;
const index = items.value.findIndex((el) => el.id === id);
if (index > -1) items.value.splice(index, 1);
emitUpdated();
};
return {
add,
canAdd,
canDrop,
handleDeleted,
handleUpdated,
items
};
}
});
//#endregion
//#region src/components/utility/form-input-list/AFormInputList.vue
const _hoisted_1$23 = { class: "d-flex flex-column gap-2" };
const _hoisted_2$14 = { class: "d-flex flex-row" };
const _hoisted_3$12 = { class: "align-self-end" };
const _hoisted_4$10 = { class: "ms-auto" };
const _hoisted_5$7 = ["disabled"];
const _hoisted_6$6 = { class: "d-flex flex-column gap-1" };
function _sfc_render$51(_ctx, _cache, $props, $setup, $data, $options) {
const _component_ATranslationDefault = resolveComponent("ATranslationDefault");
const _component_AFormInputListItem = resolveComponent("AFormInputListItem");
return openBlock(), createElementBlock("div", _hoisted_1$23, [createElementVNode("div", _hoisted_2$14, [createElementVNode("div", _hoisted_3$12, [renderSlot(_ctx.$slots, "label", {}, () => [_cache[1] || (_cache[1] = createTextVNode(" Names ", -1))])]), createElementVNode("div", _hoisted_4$10, [createElementVNode("button", {
class: "btn btn-xs btn-primary",
type: "button",
disabled: !_ctx.canAdd,
onClick: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.add(), ["prevent"]))
}, [
_cache[2] || (_cache[2] = createElementVNode("i", { class: "fa fa-plus" }, null, -1)),
_cache[3] || (_cache[3] = createTextVNode()),
createVNode(_component_ATranslationDefault, { name: "add" })
], 8, _hoisted_5$7)])]), createElementVNode("div", _hoisted_6$6, [_ctx.items.length === 0 ? renderSlot(_ctx.$slots, "noItems", { key: 0 }, () => [_cache[4] || (_cache[4] = createElementVNode("div", { class: "alert alert-sm alert-info" }, " The form list has no items yet ", -1))]) : createCommentVNode("v-if", true), (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.items, (item) => {
return renderSlot(_ctx.$slots, "default", {
key: item.id,
item,
updated: _ctx.handleUpdated,
deleted: _ctx.handleDeleted
}, () => [(openBlock(), createBlock(_component_AFormInputListItem, {
key: item.id,
disabled: !_ctx.canDrop,
name: item.value,
onUpdated: (input) => {
_ctx.handleUpdated(item.id, input);
},
onDeleted: () => {
_ctx.handleDeleted(item.id);
}
}, null, 8, [
"disabled",
"name",
"onUpdated",
"onDeleted"
]))]);
}), 128))])]);
}
var AFormInputList_default = /* @__PURE__ */ _plugin_vue_export_helper_default(AFormInputList_vue_vue_type_script_lang_default, [["render", _sfc_render$51]]);
//#endregion
//#region src/components/utility/pagination/module.ts
function buildPagination$1(ctx) {
return buildPagination({
load: (pagination) => ctx.load?.({
...ctx.meta,
pagination: {
limit: pagination.limit,
offset: pagination.offset
}
}),
total: ctx.meta?.total ?? ctx.total ?? 0,
limit: ctx.meta?.pagination?.limit ?? 0,
offset: ctx.meta?.pagination?.offset ?? 0,
busy: ctx.meta?.busy ?? ctx.busy
});
}
//#endregion
//#region src/components/utility/pagination/APagination.ts
const APagination = defineComponent({
props: {
total: { type: Number },
meta: { type: Object },
busy: { type: Boolean },
load: { type: Function }
},
setup(props) {
return () => buildPagination$1({
busy: props.busy,
load: props.load,
meta: props.meta,
total: props.total
});
}
});
//#endregion
//#region src/components/utility/entity/collection/utils/component.ts
function defineEntityCollectionVEmitOptions() {
return {
created: (_item) => true,
deleted: (_item) => true,
updated: (_item) => true
};
}
function defineEntityCollectionVProps() {
return {
query: {
type: Object,
default() {
return {};
}
},
realmId: {
type: String,
default: void 0
},
loadOnSetup: {
type: Boolean,
default: true
},
loading: {
type: [Boolean, Object],
default: true
},
noMore: {
type: [Boolean, Object],
default: true
},
footer: {
type: [Boolean, Object],
default: true
},
header: {
type: [Boolean, Object],
default: true
},
body: { type: Object }
};
}
//#endregion
//#region src/components/utility/entity/collection/utils/options.ts
function mergeListOption(primary, secondary) {
if (typeof secondary === "undefined") return primary;
if (typeof primary === "undefined") return secondary;
if (typeof primary === "boolean" && !primary) return primary;
return merge(typeof primary === "boolean" ? {} : primary, typeof secondary === "boolean" ? {} : secondary);
}
function mergeEntityCollectionRenderOptions(props, defaults) {
const output = {
body: defaults.body,
item: defaults.item
};
output.header = mergeListOption(props.header, defaults.header);
output.noMore = mergeListOption(props.noMore, defaults.noMore);
output.footer = mergeListOption(props.footer, defaults.footer);
output.loading = mergeListOption(props.loading, defaults.loading);
return output;
}
//#endregion
//#region src/components/utility/entity/collection/utils/handlers.ts
var ListHandlers = class {
data;
options;
stack;
stackProcessing;
constructor(data, options = {}) {
this.data = data;
this.options = options;
this.stack = [];
this.stackProcessing = false;
}
process() {
if (this.stackProcessing) return;
this.stackProcessing = true;
const item = this.stack.shift();
if (!item) {
this.stackProcessing = false;
return;
}
const index = this.data.value.findIndex((el) => el.id === item.data.id);
switch (item.operation) {
case "created":
if (index === -1) {
this.data.value.push(item.data);
if (this.options.created) this.options.created(item.data);
}
break;
case "updated": {
const existing = index !== -1 ? this.data.value[index] : void 0;
if (existing) {
const keys = Object.keys(item.data);
for (const key of keys) existing[key] = item.data[key];
if (this.options.updated) this.options.updated(existing);
}
break;
}
case "deleted":
if (index !== -1) {
const [output] = this.data.value.splice(index, 1);
if (this.options.deleted && output) this.options.deleted(output);
}
break;
}
this.stackProcessing = false;
this.process();
}
created(item) {
this.stack.push({
data: item,
operation: "created"
});
this.process();
}
updated(item) {
this.stack.push({
data: item,
operation: "updated"
});
this.process();
}
deleted(item) {
this.stack.push({
data: item,
operation: "deleted"
});
this.process();
}
};
//#endregion
//#region src/utils/boolable-to-object.ts
function boolableToObject(input) {
if (typeof input === "boolean") return {};
return input;
}
//#endregion
//#region src/components/utility/entity/socket/module.ts
function create$2(ctx) {
if (!isSocketManagerUsable()) return {
mount() {},
unmount() {}
};
const socketManager = injectSocketManager();
const storeRefs = storeToRefs(injectStore());
const realmId = computed(() => {
if (storeRefs.realmName.value === REALM_MASTER_NAME) return;
if (isRef(ctx.realmId)) return ctx.realmId.value;
if (ctx.realmId) return ctx.realmId;
return storeRefs.realmId.value;
});
const targetId = computed(() => isRef(ctx.targetId) ? ctx.targetId.value : ctx.targetId);
const lockId = computed(() => isRef(ctx.lockId) ? ctx.lockId.value : ctx.lockId);
const processEvent = (event) => {
if (ctx.processEvent && !ctx.processEvent(event, realmId.value)) return false;
const channelName = ctx.buildChannelName ? ctx.buildChannelName(targetId.value) : buildEntityChannelName(ctx.type, targetId.value);
if (event.meta.roomName !== channelName) return false;
if (ctx.target && (!targetId.value || targetId.value !== event.data.id)) return false;
return event.data.id !== lockId.value;
};
const handleCreated = (event) => {
if (!processEvent(event)) return;
if (ctx.onCreated) ctx.onCreated(event.data);
};
const handleUpdated = (event) => {
if (!processEvent(event)) return;
if (ctx.onUpdated) ctx.onUpdated(event.data);
};
const handleDeleted = (event) => {
if (!processEvent(event)) return;
if (ctx.onDeleted) ctx.onDeleted(event.data);
};
let mounted = false;
const mount = async () => {
if (ctx.target && !targetId.value || mounted) return;
mounted = true;
const socket = await socketManager.connect(`/resources#${realmId.value}`);
let event;
if (ctx.buildSubscribeEventName) event = ctx.buildSubscribeEventName();
else event = buildEventFullName(ctx.type, EventNameSuffix.SUBSCRIBE);
socket.emit(event, targetId.value);
if (ctx.onCreated) socket.on(buildEventFullName(ctx.type, EntityDefaultEventName.CREATED), handleCreated);
if (ctx.onUpdated) socket.on(buildEventFullName(ctx.type, EntityDefaultEventName.UPDATED), handleUpdated);
if (ctx.onDeleted) socket.on(buildEventFullName(ctx.type, EntityDefaultEventName.DELETED), handleDeleted);
};
const unmount = async () => {
if (ctx.target && !targetId.value || !mounted) return;
mounted = false;
const socket = await socketManager.connect(`/resources#${realmId.value}`);
let event;
if (ctx.buildUnsubscribeEventName) event = ctx.buildUnsubscribeEventName();
else event = buildEventFullName(ctx.type, EventNameSuffix.UNSUBSCRIBE);
socket.emit(event, targetId.value);
if (ctx.onCreated) socket.off(buildEventFullName(ctx.type, EntityDefaultEventName.UPDATED), handleCreated);
if (ctx.onUpdated) socket.off(buildEventFullName(ctx.type, EntityDefaultEventName.UPDATED), handleUpdated);
if (ctx.onDeleted) socket.off(buildEventFullName(ctx.type, EntityDefaultEventName.DELETED), handleDeleted);
};
onMounted(() => mount());
onUnmounted(() => unmount());
watch(targetId, (val, oldValue) => {
if (val !== oldValue) Promise.resolve().then(() => unmount()).then(() => mount());
});
return {
mount,
unmount
};
}
function defineEntitySocketManager(ctx) {
return create$2(ctx);
}
//#endregion
//#region src/components/utility/entity/collection/module.ts
const merger = createMerger({
array: false,
inPlace: false,
priority: "left"
});
function create$1(context) {
const data = ref([]);
const busy = ref(false);
const total = ref(0);
const meta = ref({ pagination: { limit: 10 } });
const realmId = computed(() => {
if (context.realmId) return isRef(context.realmId) ? context.realmId.value : context.realmId;
if (context.props.realmId) return context.props.realmId;
});
const client = injectHTTPClient();
let domainAPI;
if (hasOwnProperty(client, context.type)) domainAPI = client[context.type