@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/use-current-user-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-current-user-context.d.ts","sourceRoot":"/src/","sources":["use-current-user-context.jsx"],"names":[],"mappings":";AAeA;;;;;GAKG;AACH,8CAJG;IAAwB,QAAQ;IACT,KAAK,GAApB,MAAM;CACd,GAAU,OAAO,OAAO,EAAE,SAAS,CA6GrC"}
+{"version":3,"file":"use-current-user-context.d.ts","sourceRoot":"/src/","sources":["use-current-user-context.jsx"],"names":[],"mappings":";AAgBA;;;;;GAKG;AACH,8CAJG;IAAyC,QAAQ,EAAzC,OAAO,OAAO,EAAE,SAAS;IACV,KAAK,GAApB,MAAM;CACd,GAAU,OAAO,OAAO,EAAE,SAAS,CA6GrC"}

package/build/use-current-user-context.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable jest/require-hook, react/function-component-definition, sort-imports */
 import React, { useCallback, useEffect, useRef } from "react";
 import Devise from "./devise.js";
@@ -13,7 +14,7 @@ const logger = new Logger({ name: "ApiMaker / UseCurrentUserContext" });
 logger.setDebug(false);
 /**
  * @param {object} props
- * @param {Function} props.children
+ * @param {import("react").ReactNode} props.children
  * @param {string} [props.scope]
  * @returns {import("react").ReactNode}
  */
@@ -101,4 +102,4 @@ const UseCurrentUserContext = (props) => {
     return (_jsx(ScopeContext.Provider, { value: s.s.result, children: children }));
 };
 export default UseCurrentUserContext;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-current-user-context.js","sourceRoot":"/src/","sources":["use-current-user-context.jsx"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable jest/require-hook, react/function-component-definition, sort-imports */\nimport React, {useCallback, useEffect, useRef} from \"react\"\nimport Devise from \"./devise.js\"\nimport {digg} from \"diggerize\"\nimport {events} from \"./use-current-user.js\"\nimport * as inflection from \"inflection\"\nimport Logger from \"./logger.js\"\nimport Services from \"./services.js\"\nimport useEventEmitter from \"ya-use-event-emitter\"\nimport useShape from \"./use-shape.js\"\n\nconst logger = new Logger({name: \"ApiMaker / UseCurrentUserContext\"})\n\nlogger.setDebug(false)\n\n/**\n * @param {object} props\n * @param {Function} props.children\n * @param {string} [props.scope]\n * @returns {import(\"react\").ReactNode}\n */\nconst UseCurrentUserContext = (props) => {\n  const {children, scope = \"user\", ...restProps} = props\n\n  if (Object.keys(restProps).length > 0) {\n    throw new Error(`Unknown props given to UseCurrentUserContext: ${Object.keys(restProps).join(\", \")}`)\n  }\n\n  const s = useShape(props)\n  const scopeName = `current${inflection.camelize(scope)}`\n  const scopeInstance = Devise.getScope(scope)\n  const ScopeContext = scopeInstance.getContext()\n  const loadCurrentUserRequestIdRef = useRef(0)\n\n  s.meta.scope = scope\n  s.meta.scopeName = scopeName\n\n  const loadCurrentUserFromRequest = useCallback(async () => {\n    // Ignore late current-user responses from discarded mounts so the live provider controls the session state.\n    const requestId = loadCurrentUserRequestIdRef.current + 1\n\n    loadCurrentUserRequestIdRef.current = requestId\n    const {scope} = s.m\n    const getArgsMethodName = `get${inflection.camelize(scope)}Args`\n    const args = Devise[getArgsMethodName]()\n\n    logger.debug(() => `Loading ${scope} with request`)\n\n    const result = await Services.current().sendRequest(\"Devise::Current\", {query: args.query, scope})\n    const current = digg(result, \"current\")[0]\n\n    if (requestId != loadCurrentUserRequestIdRef.current) return\n\n    if (current) Devise.updateSession(current)\n\n    s.set({\n      result: {\n        loaded: true,\n        model: current\n      }\n    })\n\n    events.emit(\"currentUserLoaded\", {current})\n  }, [])\n\n  const defaultCurrentUser = useCallback(() => {\n    const {scope, scopeName} = s.m\n    let current\n\n    if (Devise.current().hasCurrentScope(s.m.scope)) {\n      current = Devise.current().getCurrentScope(scope)\n\n      logger.debug(() => `Setting ${scope} from current scope: ${current?.id()}`)\n    } else if (Devise.current().hasGlobalCurrentScope(scope)) {\n      current = Devise[scopeName]()\n\n      logger.debug(() => `Setting ${scope} from global current scope: ${current?.id()}`)\n    }\n\n    if (current) {\n      events.emit(\"currentUserLoaded\", {current})\n    }\n\n    return current\n  }, [])\n\n  s.useStates({\n    result: () => ({\n      loaded: false,\n      model: defaultCurrentUser()\n    })\n  })\n\n  const updateCurrentUser = useCallback(() => {\n    s.set({\n      result: {\n        loaded: true,\n        model: Devise[s.m.scopeName]()\n      }\n    })\n  }, [])\n\n  useEffect(() => {\n    if (!Devise.current().hasGlobalCurrentScope(s.m.scope) && !Devise.current().hasCurrentScope(s.m.scope)) {\n      logger.debug(() => `Devise hasn't got current scope ${s.m.scope} so loading from request`)\n      loadCurrentUserFromRequest()\n    }\n    return () => {\n      loadCurrentUserRequestIdRef.current += 1\n    }\n  }, [])\n\n  const onDeviseSignIn = useCallback(() => {\n    updateCurrentUser()\n  }, [])\n\n  const onDeviseSignOut = useCallback(() => {\n    updateCurrentUser()\n  }, [])\n\n  useEventEmitter(Devise.events(), \"onDeviseSignIn\", onDeviseSignIn)\n  useEventEmitter(Devise.events(), \"onDeviseSignOut\", onDeviseSignOut)\n\n  return (\n    <ScopeContext.Provider value={s.s.result}>\n      {children}\n    </ScopeContext.Provider>\n  )\n}\n\nexport default UseCurrentUserContext\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-current-user-context.js","sourceRoot":"/src/","sources":["use-current-user-context.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable jest/require-hook, react/function-component-definition, sort-imports */\nimport React, {useCallback, useEffect, useRef} from \"react\"\nimport Devise from \"./devise.js\"\nimport {digg} from \"diggerize\"\nimport {events} from \"./use-current-user.js\"\nimport * as inflection from \"inflection\"\nimport Logger from \"./logger.js\"\nimport Services from \"./services.js\"\nimport useEventEmitter from \"ya-use-event-emitter\"\nimport useShape from \"./use-shape.js\"\n\nconst logger = new Logger({name: \"ApiMaker / UseCurrentUserContext\"})\n\nlogger.setDebug(false)\n\n/**\n * @param {object} props\n * @param {import(\"react\").ReactNode} props.children\n * @param {string} [props.scope]\n * @returns {import(\"react\").ReactNode}\n */\nconst UseCurrentUserContext = (props) => {\n  const {children, scope = \"user\", ...restProps} = props\n\n  if (Object.keys(restProps).length > 0) {\n    throw new Error(`Unknown props given to UseCurrentUserContext: ${Object.keys(restProps).join(\", \")}`)\n  }\n\n  const s = useShape(props)\n  const scopeName = `current${inflection.camelize(scope)}`\n  const scopeInstance = Devise.getScope(scope)\n  const ScopeContext = scopeInstance.getContext()\n  const loadCurrentUserRequestIdRef = useRef(0)\n\n  s.meta.scope = scope\n  s.meta.scopeName = scopeName\n\n  const loadCurrentUserFromRequest = useCallback(async () => {\n    // Ignore late current-user responses from discarded mounts so the live provider controls the session state.\n    const requestId = loadCurrentUserRequestIdRef.current + 1\n\n    loadCurrentUserRequestIdRef.current = requestId\n    const {scope} = s.m\n    const getArgsMethodName = `get${inflection.camelize(scope)}Args`\n    const args = Devise[getArgsMethodName]()\n\n    logger.debug(() => `Loading ${scope} with request`)\n\n    const result = await Services.current().sendRequest(\"Devise::Current\", {query: args.query, scope})\n    const current = digg(result, \"current\")[0]\n\n    if (requestId != loadCurrentUserRequestIdRef.current) return\n\n    if (current) Devise.updateSession(current)\n\n    s.set({\n      result: {\n        loaded: true,\n        model: current\n      }\n    })\n\n    events.emit(\"currentUserLoaded\", {current})\n  }, [])\n\n  const defaultCurrentUser = useCallback(() => {\n    const {scope, scopeName} = s.m\n    let current\n\n    if (Devise.current().hasCurrentScope(s.m.scope)) {\n      current = Devise.current().getCurrentScope(scope)\n\n      logger.debug(() => `Setting ${scope} from current scope: ${current?.id()}`)\n    } else if (Devise.current().hasGlobalCurrentScope(scope)) {\n      current = Devise[scopeName]()\n\n      logger.debug(() => `Setting ${scope} from global current scope: ${current?.id()}`)\n    }\n\n    if (current) {\n      events.emit(\"currentUserLoaded\", {current})\n    }\n\n    return current\n  }, [])\n\n  s.useStates({\n    result: () => ({\n      loaded: false,\n      model: defaultCurrentUser()\n    })\n  })\n\n  const updateCurrentUser = useCallback(() => {\n    s.set({\n      result: {\n        loaded: true,\n        model: Devise[s.m.scopeName]()\n      }\n    })\n  }, [])\n\n  useEffect(() => {\n    if (!Devise.current().hasGlobalCurrentScope(s.m.scope) && !Devise.current().hasCurrentScope(s.m.scope)) {\n      logger.debug(() => `Devise hasn't got current scope ${s.m.scope} so loading from request`)\n      loadCurrentUserFromRequest()\n    }\n    return () => {\n      loadCurrentUserRequestIdRef.current += 1\n    }\n  }, [])\n\n  const onDeviseSignIn = useCallback(() => {\n    updateCurrentUser()\n  }, [])\n\n  const onDeviseSignOut = useCallback(() => {\n    updateCurrentUser()\n  }, [])\n\n  useEventEmitter(Devise.events(), \"onDeviseSignIn\", onDeviseSignIn)\n  useEventEmitter(Devise.events(), \"onDeviseSignOut\", onDeviseSignOut)\n\n  return (\n    <ScopeContext.Provider value={s.s.result}>\n      {children}\n    </ScopeContext.Provider>\n  )\n}\n\nexport default UseCurrentUserContext\n"]}

package/build/use-current-user.d.ts

@@ -1,50 +1,45 @@
 export default useCurrentUser;
-export const events: EventEmitter<string | symbol, any>;
-/**
- * @param {object} props
- * @param {string} [props.scope]
- * @param {boolean} [props.withData]
- * @returns {import("./base-model.js").default & Record<string, any>}
- */
-declare function useCurrentUser(props?: {
-    scope?: string;
-    withData?: boolean;
-}): {
-    changes: {};
+export type CurrentUserModel = ({
+    abilities: import("./base-model.js").ModelAbilityMap;
+    changes: import("./base-model.js").ModelDataMap;
+    collection: import("./collection.js").default<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: import("./base-model.js").ModelDataMap;
     newRecord: boolean;
-    relationshipsCache: {};
-    relationships: {};
-    abilities: Record<string, any>;
-    modelData: {};
-    assignAttributes(newAttributes: Record<string, any>): void;
-    attributes(): Record<string, any>;
+    previousModelData: any;
+    preloadedRelationships: import("./base-model.js").PreloadedRelationshipMap;
+    relationshipsCache: import("./base-model.js").LoadedRelationshipMap;
+    relationships: import("./base-model.js").LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    assignAttributes(newAttributes: ModelDataMap): void;
+    attributes(): ModelDataMap;
     can(givenAbilityName: string): boolean;
     clone(): /*elided*/ any;
     cacheKey(): number | string;
     localCacheKey(): string;
     fullCacheKey(): string;
-    create(attributes?: Record<string, any>, options?: object): Promise<{
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
         model: /*elided*/ any;
-        response: object;
+        response: ModelCommandResponse;
     }>;
-    createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
         model: /*elided*/ any;
-        response: any;
+        response: ModelCommandResponse;
     }>;
     destroy(): Promise<{
         model: /*elided*/ any;
-        response: object;
+        response: ModelCommandResponse;
     }>;
     ensureAbilities(listOfAbilities: string[]): Promise<void>;
-    getAttributes(): Record<string, any>;
-    handleResponseError(response: object): never;
+    getAttributes(): ModelDataMap;
+    handleResponseError(response: ModelCommandResponse): never;
     identifierKey(): number | string;
-    _identifierKey: string | number;
     isAssociationLoaded(associationName: string): boolean;
     isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
     isAssociationPresent(associationName: string): boolean;
-    ensureAssociationLoaded(associationName: string): Promise<any>;
-    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
     isAttributeChanged(attributeName: string): boolean;
     isChanged(): boolean;
     isNewRecord(): boolean;
@@ -52,74 +47,95 @@ declare function useCurrentUser(props?: {
     savedChangeToAttribute(attributeName: string): boolean;
     setNewModel(model: /*elided*/ any): void;
     setNewModelData(model: /*elided*/ any): void;
-    previousModelData: any;
-    _isDateChanged(oldValue: any, newValue: any): boolean | void;
-    _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
-    _isStringChanged(oldValue: any, newValue: any): boolean | void;
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
     modelClassData(): ModelClassDataType;
     reload(): Promise<void>;
     save(): Promise<{
         model: /*elided*/ any;
         response?: object;
     }>;
-    saveRaw(rawData: any, options?: {}): Promise<{
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
         model: /*elided*/ any;
-        response: object;
+        response: ModelCommandResponse;
     }>;
-    update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
         model: /*elided*/ any;
         response?: object;
     }>;
-    _refreshModelFromResponse(response: object): void;
-    _refreshModelDataFromResponse(response: object): void;
-    updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
         simpleModelErrors?: boolean;
     }): Promise<{
-        response: object;
+        response: ModelCommandResponse;
         model: /*elided*/ any;
     }>;
     isValid(): never;
     isValidOnServer(): Promise<{
         valid: boolean;
-        errors: Record<string, any>;
+        errors: ValidationResponseErrors;
     }>;
-    modelClass(): Record<string, any>;
+    modelClass(): BaseModelClassType;
     preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
     markForDestruction(): void;
-    _markedForDestruction: boolean;
     markedForDestruction(): boolean;
     uniqueKey(): number;
-    uniqueKeyValue: number;
-    _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
-    readAttribute(attributeName: string): any;
-    readAttributeUnderscore(attributeName: string): any;
-    isAttributeLoaded(attributeName: any): boolean;
-    _isPresent(value: any): boolean;
-    _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
-    _readBelongsToReflection({ reflectionName }: {
-        modelClass: any;
-        reflectionName: string;
-    }): any | null;
-    _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
-    _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
-    _readHasOneReflection({ reflectionName }: {
-        modelClass: any;
-        reflectionName: string;
-    }): any | null;
-    _readModelDataFromArgs(args?: {
-        data?: {
-            b?: Record<string, any>;
-            a?: Record<string, any>;
-            r?: any;
-        };
-        collection?: import("./collection.js").default<any>;
-    }): void;
-    collection: import("./collection.js").default<any>;
-    preloadedRelationships: any;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    isAttributeLoaded(attributeName: string): boolean;
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
     _readPreloadedRelationships(preloaded: {
         getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
     }): void;
     primaryKey(): number | string;
-} & Record<string, any>;
+} & {
+    name?: () => string;
+    primaryKey?: () => number | string;
+    userRoles?: () => {
+        loaded(): Array<{
+            role(): {
+                identifier(): string;
+            } | null;
+        }>;
+    };
+}) | null;
+export type CurrentUserContextValue = {
+    loaded: boolean;
+    model: CurrentUserModel;
+};
+export type UseCurrentUserArgs = {
+    scope?: string;
+    withData?: boolean;
+};
+export const events: EventEmitter<string | symbol, any>;
+/**
+ * @overload
+ * @param {{scope?: string, withData: true}} [props]
+ * @returns {CurrentUserContextValue}
+ */
+declare function useCurrentUser(props?: {
+    scope?: string;
+    withData: true;
+}): CurrentUserContextValue;
+/**
+ * @overload
+ * @param {{scope?: string, withData?: false | undefined}} [props]
+ * @returns {CurrentUserModel}
+ */
+declare function useCurrentUser(props?: {
+    scope?: string;
+    withData?: false | undefined;
+}): CurrentUserModel;
 import { EventEmitter } from "eventemitter3";
 //# sourceMappingURL=use-current-user.d.ts.map

package/build/use-current-user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-current-user.d.ts","sourceRoot":"/src/","sources":["use-current-user.js"],"names":[],"mappings":";AAMA,wDAAiC;AAKjC;;;;;GAKG;AACH,wCAJG;IAAuB,KAAK,GAApB,MAAM;IACU,QAAQ,GAAxB,OAAO;CACf,GAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2Bq5rB,CAAC;;;;;;;;gBAA2iB,CAAC;;;;;yBAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA3B3jxB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAuBnE;6BAnC0B,eAAe"}
+{"version":3,"file":"use-current-user.d.ts","sourceRoot":"/src/","sources":["use-current-user.js"],"names":[],"mappings":";+BAaa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA4Dos1B,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA5D3w7B,GAAG;IAC7C,IAAI,CAAC,EAAE,MAAM,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,MAAM,GAAG,MAAM,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM;QAAC,MAAM,IAAI,KAAK,CAAC;YAAC,IAAI,IAAI;gBAAC,UAAU,IAAI,MAAM,CAAA;aAAC,GAAG,IAAI,CAAA;SAAC,CAAC,CAAA;KAAC,CAAA;CAC7E,CAAC,GAAG,IAAI;;YAEE,OAAO;WACP,gBAAgB;;;YAEhB,MAAM;eACN,OAAO;;AAhBrB,wDAAiC;;;;;;AAoB9B,wCACQ;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAA;CAAC,GAC9B,uBAAuB,CACnC;;;;;;AAEE,wCACQ;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;CAAC,GAC5C,gBAAgB,CAC5B;6BA/B0B,eAAe"}

package/build/use-current-user.js

@@ -1,3 +1,4 @@
+// @ts-check
 /* eslint-disable jest/require-hook, sort-imports */
 import { useContext } from "react";
 import Devise from "./devise.js";
@@ -7,10 +8,31 @@ const events = new EventEmitter();
 const logger = new Logger({ name: "ApiMaker / useCurrentUser" });
 logger.setDebug(false);
 /**
- * @param {object} props
- * @param {string} [props.scope]
- * @param {boolean} [props.withData]
- * @returns {import("./base-model.js").default & Record<string, any>}
+ * @typedef {(import("./base-model.js").default & {
+ *   name?: () => string,
+ *   primaryKey?: () => number | string,
+ *   userRoles?: () => {loaded(): Array<{role(): {identifier(): string} | null}>}
+ * }) | null} CurrentUserModel
+ * @typedef {object} CurrentUserContextValue
+ * @property {boolean} loaded
+ * @property {CurrentUserModel} model
+ * @typedef {object} UseCurrentUserArgs
+ * @property {string} [scope]
+ * @property {boolean} [withData]
+ */
+/**
+ * @overload
+ * @param {{scope?: string, withData: true}} [props]
+ * @returns {CurrentUserContextValue}
+ */
+/**
+ * @overload
+ * @param {{scope?: string, withData?: false | undefined}} [props]
+ * @returns {CurrentUserModel}
+ */
+/**
+ * @param {UseCurrentUserArgs} [props]
+ * @returns {CurrentUserContextValue | CurrentUserModel}
  */
 const useCurrentUser = (props = {}) => {
     const { scope = "user", withData, ...restProps } = props;
@@ -21,17 +43,23 @@ const useCurrentUser = (props = {}) => {
     if (!scopeInstance || !scopeInstance.getContext) {
         throw new Error(`useCurrentUser: Devise scope "${scope}" is not available. Did you initialize the Devise scope provider?`);
     }
-    const currentUserContext = useContext(scopeInstance.getContext());
+    const currentUserContext = /** @type {CurrentUserContextValue | CurrentUserModel} */ (useContext(scopeInstance.getContext()));
     if (!currentUserContext) {
         throw new Error(`useCurrentUser: no context for Devise scope "${scope}". Ensure the provider is mounted before calling useCurrentUser.`);
     }
     if (withData) {
-        return currentUserContext;
+        if (typeof currentUserContext == "object" && "model" in currentUserContext) {
+            return currentUserContext;
+        }
+        throw new Error(`useCurrentUser: expected context data wrapper for scope "${scope}"`);
     }
     else {
-        return currentUserContext.model;
+        if (typeof currentUserContext == "object" && "model" in currentUserContext) {
+            return currentUserContext.model;
+        }
+        return currentUserContext;
     }
 };
 export { events };
 export default useCurrentUser;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlLWN1cnJlbnQtdXNlci5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsidXNlLWN1cnJlbnQtdXNlci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxvREFBb0Q7QUFDcEQsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLE9BQU8sQ0FBQTtBQUNoQyxPQUFPLE1BQU0sTUFBTSxhQUFhLENBQUE7QUFDaEMsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGVBQWUsQ0FBQTtBQUMxQyxPQUFPLE1BQU0sTUFBTSxhQUFhLENBQUE7QUFFaEMsTUFBTSxNQUFNLEdBQUcsSUFBSSxZQUFZLEVBQUUsQ0FBQTtBQUNqQyxNQUFNLE1BQU0sR0FBRyxJQUFJLE1BQU0sQ0FBQyxFQUFDLElBQUksRUFBRSwyQkFBMkIsRUFBQyxDQUFDLENBQUE7QUFFOUQsTUFBTSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQTtBQUV0Qjs7Ozs7R0FLRztBQUNILE1BQU0sY0FBYyxHQUFHLENBQUMsS0FBSyxHQUFHLEVBQUUsRUFBRSxFQUFFO0lBQ3BDLE1BQU0sRUFBQyxLQUFLLEdBQUcsTUFBTSxFQUFFLFFBQVEsRUFBRSxHQUFHLFNBQVMsRUFBQyxHQUFHLEtBQUssQ0FBQTtJQUV0RCxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ3RDLE1BQU0sSUFBSSxLQUFLLENBQUMsMENBQTBDLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQTtJQUNoRyxDQUFDO0lBRUQsTUFBTSxhQUFhLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUM1QyxJQUFJLENBQUMsYUFBYSxJQUFJLENBQUMsYUFBYSxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQ2hELE1BQU0sSUFBSSxLQUFLLENBQUMsaUNBQWlDLEtBQUssbUVBQW1FLENBQUMsQ0FBQTtJQUM1SCxDQUFDO0lBQ0QsTUFBTSxrQkFBa0IsR0FBRyxVQUFVLENBQUMsYUFBYSxDQUFDLFVBQVUsRUFBRSxDQUFDLENBQUE7SUFDakUsSUFBSSxDQUFDLGtCQUFrQixFQUFFLENBQUM7UUFDeEIsTUFBTSxJQUFJLEtBQUssQ0FBQyxnREFBZ0QsS0FBSyxrRUFBa0UsQ0FBQyxDQUFBO0lBQzFJLENBQUM7SUFFRCxJQUFJLFFBQVEsRUFBRSxDQUFDO1FBQ2IsT0FBTyxrQkFBa0IsQ0FBQTtJQUMzQixDQUFDO1NBQU0sQ0FBQztRQUNOLE9BQU8sa0JBQWtCLENBQUMsS0FBSyxDQUFBO0lBQ2pDLENBQUM7QUFDSCxDQUFDLENBQUE7QUFFRCxPQUFPLEVBQUMsTUFBTSxFQUFDLENBQUE7QUFDZixlQUFlLGNBQWMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIGplc3QvcmVxdWlyZS1ob29rLCBzb3J0LWltcG9ydHMgKi9cbmltcG9ydCB7dXNlQ29udGV4dH0gZnJvbSBcInJlYWN0XCJcbmltcG9ydCBEZXZpc2UgZnJvbSBcIi4vZGV2aXNlLmpzXCJcbmltcG9ydCB7RXZlbnRFbWl0dGVyfSBmcm9tIFwiZXZlbnRlbWl0dGVyM1wiXG5pbXBvcnQgTG9nZ2VyIGZyb20gXCIuL2xvZ2dlci5qc1wiXG5cbmNvbnN0IGV2ZW50cyA9IG5ldyBFdmVudEVtaXR0ZXIoKVxuY29uc3QgbG9nZ2VyID0gbmV3IExvZ2dlcih7bmFtZTogXCJBcGlNYWtlciAvIHVzZUN1cnJlbnRVc2VyXCJ9KVxuXG5sb2dnZXIuc2V0RGVidWcoZmFsc2UpXG5cbi8qKlxuICogQHBhcmFtIHtvYmplY3R9IHByb3BzXG4gKiBAcGFyYW0ge3N0cmluZ30gW3Byb3BzLnNjb3BlXVxuICogQHBhcmFtIHtib29sZWFufSBbcHJvcHMud2l0aERhdGFdXG4gKiBAcmV0dXJucyB7aW1wb3J0KFwiLi9iYXNlLW1vZGVsLmpzXCIpLmRlZmF1bHQgJiBSZWNvcmQ8c3RyaW5nLCBhbnk+fVxuICovXG5jb25zdCB1c2VDdXJyZW50VXNlciA9IChwcm9wcyA9IHt9KSA9PiB7XG4gIGNvbnN0IHtzY29wZSA9IFwidXNlclwiLCB3aXRoRGF0YSwgLi4ucmVzdFByb3BzfSA9IHByb3BzXG5cbiAgaWYgKE9iamVjdC5rZXlzKHJlc3RQcm9wcykubGVuZ3RoID4gMCkge1xuICAgIHRocm93IG5ldyBFcnJvcihgVW5rbm93biBwcm9wcyBnaXZlbiB0byB1c2VDdXJyZW50VXNlcjogJHtPYmplY3Qua2V5cyhyZXN0UHJvcHMpLmpvaW4oXCIsIFwiKX1gKVxuICB9XG5cbiAgY29uc3Qgc2NvcGVJbnN0YW5jZSA9IERldmlzZS5nZXRTY29wZShzY29wZSlcbiAgaWYgKCFzY29wZUluc3RhbmNlIHx8ICFzY29wZUluc3RhbmNlLmdldENvbnRleHQpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYHVzZUN1cnJlbnRVc2VyOiBEZXZpc2Ugc2NvcGUgXCIke3Njb3BlfVwiIGlzIG5vdCBhdmFpbGFibGUuIERpZCB5b3UgaW5pdGlhbGl6ZSB0aGUgRGV2aXNlIHNjb3BlIHByb3ZpZGVyP2ApXG4gIH1cbiAgY29uc3QgY3VycmVudFVzZXJDb250ZXh0ID0gdXNlQ29udGV4dChzY29wZUluc3RhbmNlLmdldENvbnRleHQoKSlcbiAgaWYgKCFjdXJyZW50VXNlckNvbnRleHQpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYHVzZUN1cnJlbnRVc2VyOiBubyBjb250ZXh0IGZvciBEZXZpc2Ugc2NvcGUgXCIke3Njb3BlfVwiLiBFbnN1cmUgdGhlIHByb3ZpZGVyIGlzIG1vdW50ZWQgYmVmb3JlIGNhbGxpbmcgdXNlQ3VycmVudFVzZXIuYClcbiAgfVxuXG4gIGlmICh3aXRoRGF0YSkge1xuICAgIHJldHVybiBjdXJyZW50VXNlckNvbnRleHRcbiAgfSBlbHNlIHtcbiAgICByZXR1cm4gY3VycmVudFVzZXJDb250ZXh0Lm1vZGVsXG4gIH1cbn1cblxuZXhwb3J0IHtldmVudHN9XG5leHBvcnQgZGVmYXVsdCB1c2VDdXJyZW50VXNlclxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/build/use-destroyed-event.d.ts

@@ -1,13 +1,122 @@
 export default apiMakerUseDestroyedEvent;
+export type UseDestroyedEventProps = {
+    active?: boolean;
+    debounce?: boolean | number;
+    onConnected?: () => void;
+};
+export type EventModel = {
+    abilities: import("./base-model.js").ModelAbilityMap;
+    changes: import("./base-model.js").ModelDataMap;
+    collection: import("./collection.js").default<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: import("./base-model.js").ModelDataMap;
+    newRecord: boolean;
+    previousModelData: any;
+    preloadedRelationships: import("./base-model.js").PreloadedRelationshipMap;
+    relationshipsCache: import("./base-model.js").LoadedRelationshipMap;
+    relationships: import("./base-model.js").LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    assignAttributes(newAttributes: ModelDataMap): void;
+    attributes(): ModelDataMap;
+    can(givenAbilityName: string): boolean;
+    clone(): /*elided*/ any;
+    cacheKey(): number | string;
+    localCacheKey(): string;
+    fullCacheKey(): string;
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    destroy(): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+    getAttributes(): ModelDataMap;
+    handleResponseError(response: ModelCommandResponse): never;
+    identifierKey(): number | string;
+    isAssociationLoaded(associationName: string): boolean;
+    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+    isAssociationPresent(associationName: string): boolean;
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+    isAttributeChanged(attributeName: string): boolean;
+    isChanged(): boolean;
+    isNewRecord(): boolean;
+    isPersisted(): boolean;
+    savedChangeToAttribute(attributeName: string): boolean;
+    setNewModel(model: /*elided*/ any): void;
+    setNewModelData(model: /*elided*/ any): void;
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    modelClassData(): ModelClassDataType;
+    reload(): Promise<void>;
+    save(): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        response: ModelCommandResponse;
+        model: /*elided*/ any;
+    }>;
+    isValid(): never;
+    isValidOnServer(): Promise<{
+        valid: boolean;
+        errors: ValidationResponseErrors;
+    }>;
+    modelClass(): BaseModelClassType;
+    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+    markForDestruction(): void;
+    markedForDestruction(): boolean;
+    uniqueKey(): number;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("./command-execution.js").default;
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    isAttributeLoaded(attributeName: string): boolean;
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("./collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+    _readPreloadedRelationships(preloaded: {
+        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+    }): void;
+    primaryKey(): number | string;
+};
+export type EventModelWithId = EventModel & {
+    id: () => number | string;
+};
+export type DestroyedEventPayload = {
+    model: EventModel;
+};
+export type EventCallback = (payload: DestroyedEventPayload) => void;
 /**
- * @param {import("./base-model.js").default|import("./base-model.js").default[]} model
- * @param {Function} onDestroyed
- * @param {object} [props]
- * @param {boolean} [props.active]
- * @param {number} [props.debounce]
- * @param {Function} [props.onConnected]
+ * @param {EventModel | EventModel[]} model
+ * @param {EventCallback} onDestroyed
+ * @param {UseDestroyedEventProps} [props]
  * @returns {void}
  */
-/** apiMakerUseDestroyedEvent. */
-declare function apiMakerUseDestroyedEvent(model: any, onDestroyed: any, props?: {}): void;
+declare function apiMakerUseDestroyedEvent(model: EventModel | EventModel[], onDestroyed: EventCallback, props?: UseDestroyedEventProps): void;
 //# sourceMappingURL=use-destroyed-event.d.ts.map

package/build/use-destroyed-event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-destroyed-event.d.ts","sourceRoot":"/src/","sources":["use-destroyed-event.js"],"names":[],"mappings":";AAmJA;;;;;;;;GAQG;AACH,iCAAiC;AACjC,2FAQC"}
+{"version":3,"file":"use-destroyed-event.d.ts","sourceRoot":"/src/","sources":["use-destroyed-event.js"],"names":[],"mappings":";qCAQc;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,GAAC,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2KiwvB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAzKh71B,UAAU,GAAG;IAAC,EAAE,EAAE,MAAM,MAAM,GAAC,MAAM,CAAA;CAAC;oCACtC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAC;4BACnB,CAAC,OAAO,EAAE,qBAAqB,KAAK,IAAI;AAsJtD;;;;;GAKG;AACH,kDALW,UAAU,GAAG,UAAU,EAAE,eACzB,aAAa,UACb,sBAAsB,GACpB,IAAI,CAUhB"}