@kaspernj/api-maker 1.0.2165 → 1.0.2167

package/build/bootstrap/invalid-feedback.d.ts

@@ -1,8 +1,11 @@
 export default class ApiMakerBootstrapInvalidFeedback extends React.PureComponent<any, any, any> {
-    static propTypes: any;
+    static propTypes: PropTypes.ValidationMap<{
+        errors: any[];
+    }>;
     constructor(props: any);
     render(): import("react/jsx-runtime").JSX.Element;
     errorMessages(): any[];
 }
 import React from "react";
+import PropTypes from "prop-types";
 //# sourceMappingURL=invalid-feedback.d.ts.map

package/build/bootstrap/invalid-feedback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-feedback.d.ts","sourceRoot":"/src/","sources":["bootstrap/invalid-feedback.jsx"],"names":[],"mappings":"AAMA;IACE,sBAEE;;IAEF,kDAMC;IAED,uBAWC;CACF;kBA3BiB,OAAO"}
+{"version":3,"file":"invalid-feedback.d.ts","sourceRoot":"/src/","sources":["bootstrap/invalid-feedback.jsx"],"names":[],"mappings":"AAMA;IACE;;OAEE;;IAEF,kDAMC;IAED,uBAWC;CACF;kBA3BiB,OAAO;sBAFH,YAAY"}

package/build/devise.d.ts

@@ -32,7 +32,7 @@ export default class ApiMakerDevise {
      * @param {string} username
      * @param {string} password
      * @param {DeviseScopeArgs} args
-     * @returns {Promise<{model: import("./base-model.js").default | undefined, response: DeviseSignInResponse}>}
+     * @returns {Promise<{model: import("./base-model.js").default, response: DeviseSignInResponse}>}
      */
     static signIn(username: string, password: string, args?: DeviseScopeArgs): Promise<{
         model: {
@@ -135,7 +135,7 @@ export default class ApiMakerDevise {
                 getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
             }): void;
             primaryKey(): number | string;
-        } | undefined;
+        };
         response: DeviseSignInResponse;
     }>;
     /**
@@ -147,10 +147,18 @@ export default class ApiMakerDevise {
     static persistSession(args?: DeviseScopeArgs): Promise<DeviseSessionStatusResult>;
     /**
      * Updates the locally cached current model for one scope.
-     * @param {DeviseCurrentScope} model
+     *
+     * Always requires a real model instance. Writing a falsy value here used to
+     * be a silent foot-gun: when a caller awaited a query that returned
+     * `undefined` (for example `Collection#first()` on an empty result) and
+     * passed the value through, the scope cache flipped to "signed out" without
+     * any indication, dropping the user back on the sign-in screen right after
+     * a successful sign-in. Use `Devise.setSignedOut({scope})` to sign out.
+     *
+     * @param {NonNullable<DeviseCurrentScope>} model
      * @param {DeviseScopeArgs} args
      */
-    static updateSession(model: DeviseCurrentScope, args?: DeviseScopeArgs): void;
+    static updateSession(model: NonNullable<DeviseCurrentScope>, args?: DeviseScopeArgs): void;
     /**
      * Marks one scope as signed out in the local current-model cache.
      * @param {DeviseScopeArgs} args
@@ -660,8 +668,14 @@ declare class DeviseScope {
     args: DeviseScopeArgs;
     context: import("react").Context<any>;
     scope: string;
-    /** @returns {import("react").Context<DeviseCurrentScope | undefined>} */
-    getContext: () => import("react").Context<DeviseCurrentScope | undefined>;
+    /**
+     * The Provider writes a `{loaded, model}` wrapper (see
+     * `UseCurrentUserContext`); `useCurrentUser` unwraps it on read. The
+     * context type is the wrapper, not the raw model.
+     *
+     * @returns {import("react").Context<import("./use-current-user.js").CurrentUserContextValue | undefined>}
+     */
+    getContext: () => import("react").Context<import("./use-current-user.js").CurrentUserContextValue | undefined>;
 }
 export {};
 //# sourceMappingURL=devise.d.ts.map

package/build/devise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"devise.d.ts","sourceRoot":"/src/","sources":["devise.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"devise.d.ts","sourceRoot":"/src/","sources":["devise.js"],"names":[],"mappings":"AAmDA,sBAAsB;AACtB;IACE;;;;OAIG;IACH,8BAHW,eAAe,GACb,IAAI,CAIhB;IAED,gCAAgC;IAChC,kBADc,cAAc,CAO3B;IAED;;;OAGG;IACH,iBAFa,OAAO,MAAM,CAIzB;IAED;;;;OAIG;IACH,2BAHW,MAAM,SACN,eAAe,QAezB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,WAAW,CAOvB;IAED,0BAA0B;IAC1B,2BADc,MAAM,EAAE,CAGrB;IAED;;;;;;OAMG;IACH,wBALW,MAAM,YACN,MAAM,SACN,eAAe,GACb,OAAO,CAAC;QAAC,KAAK,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2Pg6iB,CAAC;;;iCAA6O,CAAC;;;;;;;wBAAoc,CAAC;;;;;iCAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA3Pv+oB,CAAC;QAAC,QAAQ,EAAE,oBAAoB,CAAA;KAAC,CAAC,CAsC/F;IAED;;;;;OAKG;IACH,6BAHW,eAAe,GACb,OAAO,CAAC,yBAAyB,CAAC,CAkB9C;IAED;;;;;;;;;;;;OAYG;IACH,4BAHW,WAAW,CAAC,kBAAkB,CAAC,SAC/B,eAAe,QAezB;IAaD;;;OAGG;IACH,0BAFW,eAAe,QAIzB;IAED;;;;OAIG;IACH,sBAHW,eAAe,GACb,OAAO,CAAC,yBAAyB,CAAC,CAyB9C;IAED;;;;;;OAMG;IACH,kDAHW,eAAe,GACb,OAAO,CAAC,yBAAyB,CAAC,CAa9C;IAED;;;;OAIG;IACH,uDAHW,yBAAyB,GACvB,OAAO,CAAC,yBAAyB,CAAC,CAS9C;IAED;;;;;OAKG;IACH,qCAHW,eAAe,GAAG;QAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;KAAC,GAC7C,OAAO,CAAC,yBAAyB,CAAC,CAI9C;IAED;;;;;OAKG;IACH,+CAHW,eAAe,GAAG;QAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;KAAC,GAC7C,OAAO,CAAC,IAAI,CAAC,CAIzB;IArGD;;;;OAIG;IACH,uBAHW,MAAM,GACJ,OAAO,CAMnB;IAgGC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAsD27iB,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAtD79oB;IAGxE;;;;OAIG;IACH,uBAHW,MAAM,GACJ,kBAAkB,CAQ9B;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,kBAAkB,CAoB9B;CACF;mCAzWa;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,qBAAqB,CAAC,EAAE,cAAc,CAAA;CAAC;uCAC1E;IAAC,SAAS,EAAE,OAAO,CAAA;CAAC;;iBAGpB,MAAM;YACN,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC;2BACxC,MAAM;qBACN,yBAAyB;;8BAEzB;IAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CAAC;mCACrF,yBAAyB,GAAG;IAAC,KAAK,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgW44iB,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAhWn9oB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAgWw2iB,CAAC;;;6BAA6O,CAAC;;;;;;;oBAAoc,CAAC;;;;;6BAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAhW/6oB,EAAE,CAAA;CAAC;8BAC7G;IAAC,YAAY,EAAE,yBAAyB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,eAAe,CAAA;CAAC;iCACxF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA8Vi7iB,CAAC;;;yBAA6O,CAAC;;;;;;;gBAAoc,CAAC;;;;;yBAAm7E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA9Vx/oB,GAAG,IAAI;mBAjBnC,aAAa;AAuBhC,mBAAmB;AACnB;IACE;;;;OAIG;IACH,mBAHW,MAAM,QACN,eAAe,EAMzB;IAHC,sBAAgB;IAChB,sCAAuC;IACvC,cAAkB;IAGpB;;;;;;OAMG;IACH,kBAFa,OAAO,OAAO,EAAE,OAAO,CAAC,OAAO,uBAAuB,EAAE,uBAAuB,GAAG,SAAS,CAAC,CAE1E;CAChC"}

package/build/devise.js

@@ -35,7 +35,13 @@ class DeviseScope {
         this.context = createContext(undefined);
         this.scope = scope;
     }
-    /** @returns {import("react").Context<DeviseCurrentScope | undefined>} */
+    /**
+     * The Provider writes a `{loaded, model}` wrapper (see
+     * `UseCurrentUserContext`); `useCurrentUser` unwraps it on read. The
+     * context type is the wrapper, not the raw model.
+     *
+     * @returns {import("react").Context<import("./use-current-user.js").CurrentUserContextValue | undefined>}
+     */
     getContext = () => this.context;
 }
 /** ApiMakerDevise. */
@@ -99,7 +105,7 @@ export default class ApiMakerDevise {
      * @param {string} username
      * @param {string} password
      * @param {DeviseScopeArgs} args
-     * @returns {Promise<{model: import("./base-model.js").default | undefined, response: DeviseSignInResponse}>}
+     * @returns {Promise<{model: import("./base-model.js").default, response: DeviseSignInResponse}>}
      */
     static async signIn(username, password, args = {}) {
         if (!args.scope)
@@ -111,6 +117,9 @@ export default class ApiMakerDevise {
         let model = response.model;
         if (Array.isArray(model))
             model = model[0];
+        if (!model) {
+            throw new Error(`Devise.signIn: Devise::SignIn response for scope "${args.scope}" did not include a model`);
+        }
         await ApiMakerDevise.syncSessionStatusAndRefreshWebsocket({
             httpResponse: response,
             scope: args.scope,
@@ -147,12 +156,24 @@ export default class ApiMakerDevise {
     }
     /**
      * Updates the locally cached current model for one scope.
-     * @param {DeviseCurrentScope} model
+     *
+     * Always requires a real model instance. Writing a falsy value here used to
+     * be a silent foot-gun: when a caller awaited a query that returned
+     * `undefined` (for example `Collection#first()` on an empty result) and
+     * passed the value through, the scope cache flipped to "signed out" without
+     * any indication, dropping the user back on the sign-in screen right after
+     * a successful sign-in. Use `Devise.setSignedOut({scope})` to sign out.
+     *
+     * @param {NonNullable<DeviseCurrentScope>} model
      * @param {DeviseScopeArgs} args
      */
     static updateSession(model, args = {}) {
         if (!args.scope)
             args.scope = "user";
+        if (!model) {
+            throw new Error(`Devise.updateSession was called with a falsy model for scope "${args.scope}". ` +
+                "Use Devise.setSignedOut({scope}) to sign out instead.");
+        }
         const camelizedScopeName = inflection.camelize(args.scope, true);
         ApiMakerDevise.current().currents[camelizedScopeName] = model;
     }
@@ -289,4 +310,4 @@ export default class ApiMakerDevise {
         return modelInstance;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"devise.js","sourceRoot":"/src/","sources":["devise.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport * as inflection from \"inflection\" // eslint-disable-line sort-imports\nimport CableConnectionPool from \"./cable-connection-pool.js\"\nimport {createContext} from \"react\"\nimport Deserializer from \"./deserializer.js\" // eslint-disable-line sort-imports\nimport events from \"./events.js\"\nimport modelClassRequire from \"./model-class-require.js\"\nimport SessionStatusUpdater from \"./session-status-updater.js\" // eslint-disable-line sort-imports\nimport Services from \"./services.js\" // eslint-disable-line sort-imports\n\n/** @typedef {{scopes?: Record<string, boolean>, currentApiMakerDevise?: ApiMakerDevise}} ApiMakerDeviseShared */\n/** @typedef {{signed_in: boolean}} DeviseSessionStatusScope */\n/**\n * @typedef {object} DeviseSessionStatusResult\n * @property {string} [csrf_token]\n * @property {Record<string, DeviseSessionStatusScope>} scopes\n * @property {string} [shadow_session_token]\n * @property {DeviseSessionStatusResult} [session_status]\n */\n/** @typedef {{rememberMe?: boolean, scope?: string, signedIn?: boolean, skipSignInEvent?: boolean}} DeviseScopeArgs */\n/** @typedef {DeviseSessionStatusResult & {model?: import(\"./base-model.js\").default | import(\"./base-model.js\").default[]}} DeviseSignInResponse */\n/** @typedef {{httpResponse: DeviseSessionStatusResult, scope: string, websocketArgs: DeviseScopeArgs}} SyncSessionArgs */\n/** @typedef {import(\"./base-model.js\").default | null} DeviseCurrentScope */\n\nif (!globalThis.ApiMakerDevise) globalThis.ApiMakerDevise = {scopes: {}}\n\nconst shared = /** @type {ApiMakerDeviseShared} */ (globalThis.ApiMakerDevise)\n\n/** DeviseScope. */\nclass DeviseScope {\n  /**\n   * Constructor.\n   * @param {string} scope\n   * @param {DeviseScopeArgs} args\n   */\n  constructor(scope, args) {\n    this.args = args\n    this.context = createContext(undefined)\n    this.scope = scope\n  }\n\n  /** @returns {import(\"react\").Context<DeviseCurrentScope | undefined>} */\n  getContext = () => this.context\n}\n\n/** ApiMakerDevise. */\nexport default class ApiMakerDevise {\n  /**\n   * Emits the shared sign-out event payload for one scope.\n   * @param {DeviseScopeArgs} args\n   * @returns {void}\n   */\n  static callSignOutEvent(args) {\n    events.emit(\"onDeviseSignOut\", {args})\n  }\n\n  /** @returns {ApiMakerDevise} */\n  static current() {\n    if (!shared.currentApiMakerDevise) {\n      shared.currentApiMakerDevise = new ApiMakerDevise()\n    }\n\n    return shared.currentApiMakerDevise\n  }\n\n  /**\n   * Returns the shared event emitter used for Devise lifecycle events.\n   * @returns {typeof events}\n   */\n  static events() {\n    return events\n  }\n\n  /**\n   * Registers one Devise scope and its helper accessors.\n   * @param {string} scope\n   * @param {DeviseScopeArgs} args\n   */\n  static addUserScope(scope, args = {}) {\n    const scopeCamelized = inflection.camelize(scope)\n    const currentMethodName = `current${scopeCamelized}`\n    const isSignedInMethodName = `is${scopeCamelized}SignedIn`\n    const getArgsMethodName = `get${scopeCamelized}Args`\n    const getScopeName = `get${scopeCamelized}Scope`\n    const scopeInstance = new DeviseScope(scope, args)\n\n    shared.scopes[scope] = true\n    ApiMakerDevise[currentMethodName] = () => ApiMakerDevise.current().getCurrentScope(scope)\n    ApiMakerDevise[isSignedInMethodName] = () => Boolean(ApiMakerDevise.current().getCurrentScope(scope))\n    ApiMakerDevise[getArgsMethodName] = () => args\n    ApiMakerDevise[getScopeName] = () => scopeInstance\n  }\n\n  /**\n   * Returns the registered scope helper for one scope name.\n   * @param {string} scope\n   * @returns {DeviseScope}\n   */\n  static getScope(scope) {\n    const scopeCamelized = inflection.camelize(scope)\n    const getScopeName = `get${scopeCamelized}Scope`\n\n    return ApiMakerDevise[getScopeName]()\n  }\n\n  /** @returns {string[]} */\n  static registeredScopes() {\n    return Object.keys(shared.scopes)\n  }\n\n  /**\n   * Signs in one scope over HTTP and refreshes websocket auth state.\n   * @param {string} username\n   * @param {string} password\n   * @param {DeviseScopeArgs} args\n   * @returns {Promise<{model: import(\"./base-model.js\").default | undefined, response: DeviseSignInResponse}>}\n   */\n  static async signIn(username, password, args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const postData = {username, password, args}\n\n    // Sign in over HTTP first so Devise can write the real session cookie and\n    // remember-me token in the HTTP response.\n    const response = /** @type {DeviseSignInResponse} */ (\n      await Services.current().sendRequest(\"Devise::SignIn\", postData, {forceHttp: true})\n    )\n\n    let model = response.model\n\n    if (Array.isArray(model)) model = model[0]\n\n    await ApiMakerDevise.syncSessionStatusAndRefreshWebsocket({\n      httpResponse: response,\n      scope: args.scope,\n      websocketArgs: {\n        rememberMe: args.rememberMe,\n        scope: args.scope,\n        signedIn: true\n      }\n    })\n\n    ApiMakerDevise.updateSession(model)\n\n    if (!args.skipSignInEvent) {\n      events.emit(\"onDeviseSignIn\", {username, ...args})\n    }\n\n    return {model, response}\n  }\n\n  /**\n   * Synchronizes the current backend auth state into real HTTP response cookies.\n   *\n   * @param {DeviseScopeArgs} [args]\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async persistSession(args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const response = /** @type {DeviseSessionStatusResult} */ (\n      await Services.current().sendRequest(\"Devise::PersistSession\", args, {forceHttp: true})\n    )\n\n    const sessionStatusUpdater = SessionStatusUpdater.current()\n\n    if (response.session_status) {\n      sessionStatusUpdater.applyResult(response.session_status)\n    } else {\n      await sessionStatusUpdater.updateSessionStatus()\n    }\n\n    return response\n  }\n\n  /**\n   * Updates the locally cached current model for one scope.\n   * @param {DeviseCurrentScope} model\n   * @param {DeviseScopeArgs} args\n   */\n  static updateSession(model, args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const camelizedScopeName = inflection.camelize(args.scope, true)\n\n    ApiMakerDevise.current().currents[camelizedScopeName] = model\n  }\n\n  /**\n   * Returns whether the current scope cache has been initialized locally.\n   * @param {string} scope\n   * @returns {boolean}\n   */\n  hasCurrentScope(scope) {\n    const camelizedScopeName = inflection.camelize(scope, true)\n\n    return camelizedScopeName in ApiMakerDevise.current().currents\n  }\n\n  /**\n   * Marks one scope as signed out in the local current-model cache.\n   * @param {DeviseScopeArgs} args\n   */\n  static setSignedOut(args) {\n    ApiMakerDevise.current().currents[inflection.camelize(args.scope, true)] = null\n  }\n\n  /**\n   * Signs out one scope over HTTP and refreshes websocket auth state.\n   * @param {DeviseScopeArgs} args\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async signOut(args = {}) {\n    if (!args.scope) {\n      args.scope = \"user\"\n    }\n\n    const response = /** @type {DeviseSessionStatusResult} */ (\n      await Services.current().sendRequest(\"Devise::SignOut\", {args}, {forceHttp: true})\n    )\n    const sessionStatus = await ApiMakerDevise.syncSessionStatusAndRefreshWebsocket({\n      httpResponse: response,\n      scope: args.scope,\n      websocketArgs: {\n        scope: args.scope,\n        signedIn: false\n      }\n    })\n\n    if (!sessionStatus.scopes?.[args.scope]?.signed_in) {\n      ApiMakerDevise.setSignedOut(args)\n      ApiMakerDevise.callSignOutEvent(args)\n    }\n\n    return response\n  }\n\n  /**\n   * Applies the latest HTTP session status locally, then refreshes the\n   * existing websocket connection so ApiMaker commands use the same auth.\n   *\n   * @param {SyncSessionArgs} args\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async syncSessionStatusAndRefreshWebsocket(args) {\n    const sessionStatus = await ApiMakerDevise.syncSessionStatusFromHttpResponse(args.httpResponse)\n    const websocketArgs = {\n      ...args.websocketArgs,\n      shadowSessionToken: sessionStatus.shadow_session_token\n    }\n\n    await ApiMakerDevise.refreshWebsocketSession(websocketArgs)\n    await ApiMakerDevise.refreshSubscriptionAuthentication(websocketArgs)\n\n    return sessionStatus\n  }\n\n  /**\n   * Updates local session status from one HTTP response payload.\n   * @param {DeviseSessionStatusResult} httpResponse\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async syncSessionStatusFromHttpResponse(httpResponse) {\n    const sessionStatusUpdater = SessionStatusUpdater.current()\n    const sessionStatus = httpResponse.session_status || await sessionStatusUpdater.sessionStatus()\n\n    sessionStatusUpdater.applyResult(sessionStatus)\n\n    return sessionStatus\n  }\n\n  /**\n   * Refreshes ApiMaker auth inside the existing websocket connection.\n   *\n   * @param {DeviseScopeArgs & {shadowSessionToken?: string}} args\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async refreshWebsocketSession(args) {\n    return /** @type {DeviseSessionStatusResult} */ (await Services.current().sendRequest(\"Devise::PersistSession\", args))\n  }\n\n  /**\n   * Refreshes auth on the existing subscriptions channel pools.\n   *\n   * @param {DeviseScopeArgs & {shadowSessionToken?: string}} args\n   * @returns {Promise<void>}\n   */\n  static async refreshSubscriptionAuthentication(args) {\n    await CableConnectionPool.current().refreshAuthentication(args)\n  }\n\n  /** Constructor. */\n  constructor() {\n    this.currents = /** @type {Record<string, DeviseCurrentScope>} */ ({})\n  }\n\n  /**\n   * Returns the current model cached for one scope.\n   * @param {string} scope\n   * @returns {DeviseCurrentScope}\n   */\n  getCurrentScope(scope) {\n    if (!(scope in this.currents)) {\n      this.currents[scope] = this.loadCurrentScope(scope)\n    }\n\n    return this.currents[scope]\n  }\n\n  /**\n   * Returns whether the server rendered current-scope payload for one scope.\n   * @param {string} scope\n   * @returns {boolean}\n   */\n  hasGlobalCurrentScope(scope) {\n    if (globalThis.apiMakerDeviseCurrent && scope in globalThis.apiMakerDeviseCurrent) {\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Hydrates the current scope model from the server rendered payload.\n   * @param {string} scope\n   * @returns {DeviseCurrentScope}\n   */\n  loadCurrentScope(scope) {\n    if (!this.hasGlobalCurrentScope(scope)) {\n      return null\n    }\n\n    const scopeData = globalThis.apiMakerDeviseCurrent[scope]\n\n    if (!scopeData) return null\n\n    const parsedScopeData = Deserializer.parse(scopeData)\n\n    // Might be a collection with preloaded relationships\n    if (Array.isArray(parsedScopeData)) return parsedScopeData[0]\n\n    const ModelClass = modelClassRequire(scope)\n    const modelInstance = new ModelClass({data: parsedScopeData})\n\n    return modelInstance\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"devise.js","sourceRoot":"/src/","sources":["devise.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport * as inflection from \"inflection\" // eslint-disable-line sort-imports\nimport CableConnectionPool from \"./cable-connection-pool.js\"\nimport {createContext} from \"react\"\nimport Deserializer from \"./deserializer.js\" // eslint-disable-line sort-imports\nimport events from \"./events.js\"\nimport modelClassRequire from \"./model-class-require.js\"\nimport SessionStatusUpdater from \"./session-status-updater.js\" // eslint-disable-line sort-imports\nimport Services from \"./services.js\" // eslint-disable-line sort-imports\n\n/** @typedef {{scopes?: Record<string, boolean>, currentApiMakerDevise?: ApiMakerDevise}} ApiMakerDeviseShared */\n/** @typedef {{signed_in: boolean}} DeviseSessionStatusScope */\n/**\n * @typedef {object} DeviseSessionStatusResult\n * @property {string} [csrf_token]\n * @property {Record<string, DeviseSessionStatusScope>} scopes\n * @property {string} [shadow_session_token]\n * @property {DeviseSessionStatusResult} [session_status]\n */\n/** @typedef {{rememberMe?: boolean, scope?: string, signedIn?: boolean, skipSignInEvent?: boolean}} DeviseScopeArgs */\n/** @typedef {DeviseSessionStatusResult & {model?: import(\"./base-model.js\").default | import(\"./base-model.js\").default[]}} DeviseSignInResponse */\n/** @typedef {{httpResponse: DeviseSessionStatusResult, scope: string, websocketArgs: DeviseScopeArgs}} SyncSessionArgs */\n/** @typedef {import(\"./base-model.js\").default | null} DeviseCurrentScope */\n\nif (!globalThis.ApiMakerDevise) globalThis.ApiMakerDevise = {scopes: {}}\n\nconst shared = /** @type {ApiMakerDeviseShared} */ (globalThis.ApiMakerDevise)\n\n/** DeviseScope. */\nclass DeviseScope {\n  /**\n   * Constructor.\n   * @param {string} scope\n   * @param {DeviseScopeArgs} args\n   */\n  constructor(scope, args) {\n    this.args = args\n    this.context = createContext(undefined)\n    this.scope = scope\n  }\n\n  /**\n   * The Provider writes a `{loaded, model}` wrapper (see\n   * `UseCurrentUserContext`); `useCurrentUser` unwraps it on read. The\n   * context type is the wrapper, not the raw model.\n   *\n   * @returns {import(\"react\").Context<import(\"./use-current-user.js\").CurrentUserContextValue | undefined>}\n   */\n  getContext = () => this.context\n}\n\n/** ApiMakerDevise. */\nexport default class ApiMakerDevise {\n  /**\n   * Emits the shared sign-out event payload for one scope.\n   * @param {DeviseScopeArgs} args\n   * @returns {void}\n   */\n  static callSignOutEvent(args) {\n    events.emit(\"onDeviseSignOut\", {args})\n  }\n\n  /** @returns {ApiMakerDevise} */\n  static current() {\n    if (!shared.currentApiMakerDevise) {\n      shared.currentApiMakerDevise = new ApiMakerDevise()\n    }\n\n    return shared.currentApiMakerDevise\n  }\n\n  /**\n   * Returns the shared event emitter used for Devise lifecycle events.\n   * @returns {typeof events}\n   */\n  static events() {\n    return events\n  }\n\n  /**\n   * Registers one Devise scope and its helper accessors.\n   * @param {string} scope\n   * @param {DeviseScopeArgs} args\n   */\n  static addUserScope(scope, args = {}) {\n    const scopeCamelized = inflection.camelize(scope)\n    const currentMethodName = `current${scopeCamelized}`\n    const isSignedInMethodName = `is${scopeCamelized}SignedIn`\n    const getArgsMethodName = `get${scopeCamelized}Args`\n    const getScopeName = `get${scopeCamelized}Scope`\n    const scopeInstance = new DeviseScope(scope, args)\n\n    shared.scopes[scope] = true\n    ApiMakerDevise[currentMethodName] = () => ApiMakerDevise.current().getCurrentScope(scope)\n    ApiMakerDevise[isSignedInMethodName] = () => Boolean(ApiMakerDevise.current().getCurrentScope(scope))\n    ApiMakerDevise[getArgsMethodName] = () => args\n    ApiMakerDevise[getScopeName] = () => scopeInstance\n  }\n\n  /**\n   * Returns the registered scope helper for one scope name.\n   * @param {string} scope\n   * @returns {DeviseScope}\n   */\n  static getScope(scope) {\n    const scopeCamelized = inflection.camelize(scope)\n    const getScopeName = `get${scopeCamelized}Scope`\n\n    return ApiMakerDevise[getScopeName]()\n  }\n\n  /** @returns {string[]} */\n  static registeredScopes() {\n    return Object.keys(shared.scopes)\n  }\n\n  /**\n   * Signs in one scope over HTTP and refreshes websocket auth state.\n   * @param {string} username\n   * @param {string} password\n   * @param {DeviseScopeArgs} args\n   * @returns {Promise<{model: import(\"./base-model.js\").default, response: DeviseSignInResponse}>}\n   */\n  static async signIn(username, password, args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const postData = {username, password, args}\n\n    // Sign in over HTTP first so Devise can write the real session cookie and\n    // remember-me token in the HTTP response.\n    const response = /** @type {DeviseSignInResponse} */ (\n      await Services.current().sendRequest(\"Devise::SignIn\", postData, {forceHttp: true})\n    )\n\n    let model = response.model\n\n    if (Array.isArray(model)) model = model[0]\n\n    if (!model) {\n      throw new Error(`Devise.signIn: Devise::SignIn response for scope \"${args.scope}\" did not include a model`)\n    }\n\n    await ApiMakerDevise.syncSessionStatusAndRefreshWebsocket({\n      httpResponse: response,\n      scope: args.scope,\n      websocketArgs: {\n        rememberMe: args.rememberMe,\n        scope: args.scope,\n        signedIn: true\n      }\n    })\n\n    ApiMakerDevise.updateSession(model)\n\n    if (!args.skipSignInEvent) {\n      events.emit(\"onDeviseSignIn\", {username, ...args})\n    }\n\n    return {model, response}\n  }\n\n  /**\n   * Synchronizes the current backend auth state into real HTTP response cookies.\n   *\n   * @param {DeviseScopeArgs} [args]\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async persistSession(args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const response = /** @type {DeviseSessionStatusResult} */ (\n      await Services.current().sendRequest(\"Devise::PersistSession\", args, {forceHttp: true})\n    )\n\n    const sessionStatusUpdater = SessionStatusUpdater.current()\n\n    if (response.session_status) {\n      sessionStatusUpdater.applyResult(response.session_status)\n    } else {\n      await sessionStatusUpdater.updateSessionStatus()\n    }\n\n    return response\n  }\n\n  /**\n   * Updates the locally cached current model for one scope.\n   *\n   * Always requires a real model instance. Writing a falsy value here used to\n   * be a silent foot-gun: when a caller awaited a query that returned\n   * `undefined` (for example `Collection#first()` on an empty result) and\n   * passed the value through, the scope cache flipped to \"signed out\" without\n   * any indication, dropping the user back on the sign-in screen right after\n   * a successful sign-in. Use `Devise.setSignedOut({scope})` to sign out.\n   *\n   * @param {NonNullable<DeviseCurrentScope>} model\n   * @param {DeviseScopeArgs} args\n   */\n  static updateSession(model, args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    if (!model) {\n      throw new Error(\n        `Devise.updateSession was called with a falsy model for scope \"${args.scope}\". ` +\n        \"Use Devise.setSignedOut({scope}) to sign out instead.\"\n      )\n    }\n\n    const camelizedScopeName = inflection.camelize(args.scope, true)\n\n    ApiMakerDevise.current().currents[camelizedScopeName] = model\n  }\n\n  /**\n   * Returns whether the current scope cache has been initialized locally.\n   * @param {string} scope\n   * @returns {boolean}\n   */\n  hasCurrentScope(scope) {\n    const camelizedScopeName = inflection.camelize(scope, true)\n\n    return camelizedScopeName in ApiMakerDevise.current().currents\n  }\n\n  /**\n   * Marks one scope as signed out in the local current-model cache.\n   * @param {DeviseScopeArgs} args\n   */\n  static setSignedOut(args) {\n    ApiMakerDevise.current().currents[inflection.camelize(args.scope, true)] = null\n  }\n\n  /**\n   * Signs out one scope over HTTP and refreshes websocket auth state.\n   * @param {DeviseScopeArgs} args\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async signOut(args = {}) {\n    if (!args.scope) {\n      args.scope = \"user\"\n    }\n\n    const response = /** @type {DeviseSessionStatusResult} */ (\n      await Services.current().sendRequest(\"Devise::SignOut\", {args}, {forceHttp: true})\n    )\n    const sessionStatus = await ApiMakerDevise.syncSessionStatusAndRefreshWebsocket({\n      httpResponse: response,\n      scope: args.scope,\n      websocketArgs: {\n        scope: args.scope,\n        signedIn: false\n      }\n    })\n\n    if (!sessionStatus.scopes?.[args.scope]?.signed_in) {\n      ApiMakerDevise.setSignedOut(args)\n      ApiMakerDevise.callSignOutEvent(args)\n    }\n\n    return response\n  }\n\n  /**\n   * Applies the latest HTTP session status locally, then refreshes the\n   * existing websocket connection so ApiMaker commands use the same auth.\n   *\n   * @param {SyncSessionArgs} args\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async syncSessionStatusAndRefreshWebsocket(args) {\n    const sessionStatus = await ApiMakerDevise.syncSessionStatusFromHttpResponse(args.httpResponse)\n    const websocketArgs = {\n      ...args.websocketArgs,\n      shadowSessionToken: sessionStatus.shadow_session_token\n    }\n\n    await ApiMakerDevise.refreshWebsocketSession(websocketArgs)\n    await ApiMakerDevise.refreshSubscriptionAuthentication(websocketArgs)\n\n    return sessionStatus\n  }\n\n  /**\n   * Updates local session status from one HTTP response payload.\n   * @param {DeviseSessionStatusResult} httpResponse\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async syncSessionStatusFromHttpResponse(httpResponse) {\n    const sessionStatusUpdater = SessionStatusUpdater.current()\n    const sessionStatus = httpResponse.session_status || await sessionStatusUpdater.sessionStatus()\n\n    sessionStatusUpdater.applyResult(sessionStatus)\n\n    return sessionStatus\n  }\n\n  /**\n   * Refreshes ApiMaker auth inside the existing websocket connection.\n   *\n   * @param {DeviseScopeArgs & {shadowSessionToken?: string}} args\n   * @returns {Promise<DeviseSessionStatusResult>}\n   */\n  static async refreshWebsocketSession(args) {\n    return /** @type {DeviseSessionStatusResult} */ (await Services.current().sendRequest(\"Devise::PersistSession\", args))\n  }\n\n  /**\n   * Refreshes auth on the existing subscriptions channel pools.\n   *\n   * @param {DeviseScopeArgs & {shadowSessionToken?: string}} args\n   * @returns {Promise<void>}\n   */\n  static async refreshSubscriptionAuthentication(args) {\n    await CableConnectionPool.current().refreshAuthentication(args)\n  }\n\n  /** Constructor. */\n  constructor() {\n    this.currents = /** @type {Record<string, DeviseCurrentScope>} */ ({})\n  }\n\n  /**\n   * Returns the current model cached for one scope.\n   * @param {string} scope\n   * @returns {DeviseCurrentScope}\n   */\n  getCurrentScope(scope) {\n    if (!(scope in this.currents)) {\n      this.currents[scope] = this.loadCurrentScope(scope)\n    }\n\n    return this.currents[scope]\n  }\n\n  /**\n   * Returns whether the server rendered current-scope payload for one scope.\n   * @param {string} scope\n   * @returns {boolean}\n   */\n  hasGlobalCurrentScope(scope) {\n    if (globalThis.apiMakerDeviseCurrent && scope in globalThis.apiMakerDeviseCurrent) {\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Hydrates the current scope model from the server rendered payload.\n   * @param {string} scope\n   * @returns {DeviseCurrentScope}\n   */\n  loadCurrentScope(scope) {\n    if (!this.hasGlobalCurrentScope(scope)) {\n      return null\n    }\n\n    const scopeData = globalThis.apiMakerDeviseCurrent[scope]\n\n    if (!scopeData) return null\n\n    const parsedScopeData = Deserializer.parse(scopeData)\n\n    // Might be a collection with preloaded relationships\n    if (Array.isArray(parsedScopeData)) return parsedScopeData[0]\n\n    const ModelClass = modelClassRequire(scope)\n    const modelInstance = new ModelClass({data: parsedScopeData})\n\n    return modelInstance\n  }\n}\n"]}

package/build/event-connection.d.ts

@@ -2,7 +2,12 @@ export default class ApiMakerEventConnection extends React.PureComponent<any, an
     static defaultProps: {
         active: boolean;
     };
-    static propTypes: any;
+    static propTypes: PropTypes.ValidationMap<{
+        active: boolean;
+        model: object;
+        event: string;
+        onCall: (...args: any[]) => any;
+    }>;
     constructor(props: any);
     componentDidMount(): void;
     subscription: import("./cable-subscription.js").default;
@@ -11,4 +16,5 @@ export default class ApiMakerEventConnection extends React.PureComponent<any, an
     onCall(...args: any[]): void;
 }
 import React from "react";
+import PropTypes from "prop-types";
 //# sourceMappingURL=event-connection.d.ts.map

package/build/event-connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-connection.d.ts","sourceRoot":"/src/","sources":["event-connection.jsx"],"names":[],"mappings":"AAMA;IACE;;MAEC;IAED,sBAKE;;IAEF,0BAEC;IADC,wDAA8G;IAGhH,6BAIC;IAED,cAEC;IAED,6BAIC;CACF;kBAlCiB,OAAO"}
+{"version":3,"file":"event-connection.d.ts","sourceRoot":"/src/","sources":["event-connection.jsx"],"names":[],"mappings":"AAMA;IACE;;MAEC;IAED;;;;;OAKE;;IAEF,0BAEC;IADC,wDAA8G;IAGhH,6BAIC;IAED,cAEC;IAED,6BAIC;CACF;kBAlCiB,OAAO;sBADH,YAAY"}

package/build/event-model-class.d.ts

@@ -1,5 +1,9 @@
 export default class ApiMakerEventModelClass extends React.PureComponent<any, any, any> {
-    static propTypes: any;
+    static propTypes: PropTypes.ValidationMap<{
+        event: string;
+        modelClass: (...args: any[]) => any;
+        onCall: (...args: any[]) => any;
+    }>;
     constructor(props: any);
     componentDidMount(): void;
     componentWillUnmount(): void;
@@ -8,4 +12,5 @@ export default class ApiMakerEventModelClass extends React.PureComponent<any, an
     render(): any;
 }
 import React from "react";
+import PropTypes from "prop-types";
 //# sourceMappingURL=event-model-class.d.ts.map

package/build/event-model-class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-model-class.d.ts","sourceRoot":"/src/","sources":["event-model-class.jsx"],"names":[],"mappings":"AAMA;IACE,sBAIE;;IAEF,0BAEC;IAED,6BAIC;IAED,gBAEC;IADC,sDAA2G;IAG7G,cAEC;CACF;kBA3BiB,OAAO"}
+{"version":3,"file":"event-model-class.d.ts","sourceRoot":"/src/","sources":["event-model-class.jsx"],"names":[],"mappings":"AAMA;IACE;;;;OAIE;;IAEF,0BAEC;IAED,6BAIC;IAED,gBAEC;IADC,sDAA2G;IAG7G,cAEC;CACF;kBA3BiB,OAAO;sBADH,YAAY"}

package/build/updated-attribute.d.ts

@@ -1,5 +1,9 @@
 export default class ApiMakerUpdatedAttribute extends React.PureComponent<any, any, any> {
-    static propTypes: any;
+    static propTypes: PropTypes.ValidationMap<{
+        attribute: string;
+        model: object;
+        onValue: (...args: any[]) => any;
+    }>;
     constructor(props: any);
     state: {
         model: any;
@@ -13,4 +17,5 @@ export default class ApiMakerUpdatedAttribute extends React.PureComponent<any, a
     render(): any;
 }
 import React from "react";
+import PropTypes from "prop-types";
 //# sourceMappingURL=updated-attribute.d.ts.map

package/build/updated-attribute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updated-attribute.d.ts","sourceRoot":"/src/","sources":["updated-attribute.jsx"],"names":[],"mappings":"AAQA;IACE,sBAIE;IAEF,wBAKC;IAHC;;MAEC;IAGH,0BAGC;IAED,6BAKC;IAED,gBAWC;IAVC,0DASE;IAIJ,wCAqBC;IAED,qBAgBC;IAED,cAIC;CACF;kBAxFiB,OAAO"}
+{"version":3,"file":"updated-attribute.d.ts","sourceRoot":"/src/","sources":["updated-attribute.jsx"],"names":[],"mappings":"AAQA;IACE;;;;OAIE;IAEF,wBAKC;IAHC;;MAEC;IAGH,0BAGC;IAED,6BAKC;IAED,gBAWC;IAVC,0DASE;IAIJ,wCAqBC;IAED,qBAgBC;IAED,cAIC;CACF;kBAxFiB,OAAO;sBAFH,YAAY"}

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

@@ -1,12 +1,16 @@
-export default UseCurrentUserContext;
-/**
- * @param {object} props
- * @param {import("react").ReactNode} props.children
- * @param {string} [props.scope]
- * @returns {import("react").ReactNode}
- */
-declare function UseCurrentUserContext(props: {
+declare const _default: React.NamedExoticComponent<Record<string, any>>;
+export default _default;
+export type CurrentUserModel = import("./use-current-user.js").CurrentUserModel;
+export type Result = {
+    loaded: boolean;
+    model: CurrentUserModel;
+};
+export type Props = {
     children: import("react").ReactNode;
     scope?: string;
-}): import("react").ReactNode;
+};
+export type State = {
+    result: Result;
+};
+import React from "react";
 //# sourceMappingURL=use-current-user-context.d.ts.map

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":";AAgBA;;;;;GAKG;AACH,8CAJG;IAAyC,QAAQ,EAAzC,OAAO,OAAO,EAAE,SAAS;IACV,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":";;+BAkBa,OAAO,uBAAuB,EAAE,gBAAgB;;YAI/C,OAAO;WACP,gBAAgB;;;cAIhB,OAAO,OAAO,EAAE,SAAS;YACzB,MAAM;;;YAIN,MAAM;;kBA1BF,OAAO"}

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

@@ -1,105 +1,133 @@
 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";
-import { digg } from "diggerize";
-import { events } from "./use-current-user.js";
 import * as inflection from "inflection";
+import { ShapeComponent, shapeComponent } from "set-state-compare/build/shape-component.js";
+import Devise from "./devise.js";
 import Logger from "./logger.js";
+import PropTypes from "prop-types";
+import React from "react";
 import Services from "./services.js";
+import { digg } from "diggerize";
+import { events } from "./use-current-user.js";
+import memo from "set-state-compare/build/memo.js";
+import propTypesExact from "prop-types-exact";
 import useEventEmitter from "ya-use-event-emitter";
-import useShape from "./use-shape.js";
+import useNow from "set-state-compare/build/use-now.js";
 const logger = new Logger({ name: "ApiMaker / UseCurrentUserContext" });
-logger.setDebug(false);
 /**
- * @param {object} props
- * @param {import("react").ReactNode} props.children
- * @param {string} [props.scope]
- * @returns {import("react").ReactNode}
+ * @typedef {import("./use-current-user.js").CurrentUserModel} CurrentUserModel
  */
-const UseCurrentUserContext = (props) => {
-    const { children, scope = "user", ...restProps } = props;
-    if (Object.keys(restProps).length > 0) {
-        throw new Error(`Unknown props given to UseCurrentUserContext: ${Object.keys(restProps).join(", ")}`);
+/**
+ * @typedef {object} Result
+ * @property {boolean} loaded
+ * @property {CurrentUserModel} model
+ */
+/**
+ * @typedef {object} Props
+ * @property {import("react").ReactNode} children
+ * @property {string} [scope]
+ */
+/**
+ * @typedef {object} State
+ * @property {Result} result
+ */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerUseCurrentUserContext extends ShapeComponent {
+    static propTypes = propTypesExact({
+        children: PropTypes.node,
+        scope: PropTypes.string
+    });
+    static defaultProps = {
+        scope: "user"
+    };
+    state = {
+        result: /** @type {Result} */ ({
+            loaded: false,
+            model: null
+        })
+    };
+    loadCurrentUserRequestId = 0;
+    /** @type {import("react").Context<import("./use-current-user.js").CurrentUserContextValue | undefined>} */
+    ScopeContext;
+    /** @type {string} */
+    scope;
+    /** @type {string} */
+    scopeName;
+    setup() {
+        const scope = this.p.scope ?? "user";
+        const scopeName = `current${inflection.camelize(scope)}`;
+        const scopeInstance = Devise.getScope(scope);
+        this.scope = scope;
+        this.scopeName = scopeName;
+        this.ScopeContext = scopeInstance.getContext();
+        useNow(() => {
+            if (Devise.current().hasCurrentScope(this.scope) || Devise.current().hasGlobalCurrentScope(this.scope)) {
+                this.s.result = { loaded: false, model: this.defaultCurrentUser() ?? null };
+            }
+        }, []);
+        React.useEffect(() => {
+            if (!Devise.current().hasGlobalCurrentScope(this.scope) && !Devise.current().hasCurrentScope(this.scope)) {
+                logger.debug(() => `Devise hasn't got current scope ${this.scope} so loading from request`);
+                this.loadCurrentUserFromRequest();
+            }
+            // Discard any in-flight current-user load when this instance tears down.
+            return () => {
+                this.loadCurrentUserRequestId += 1;
+            };
+        }, []);
+        useEventEmitter(Devise.events(), "onDeviseSignIn", this.tt.onDeviseSignIn);
+        useEventEmitter(Devise.events(), "onDeviseSignOut", this.tt.onDeviseSignOut);
     }
-    const s = useShape(props);
-    const scopeName = `current${inflection.camelize(scope)}`;
-    const scopeInstance = Devise.getScope(scope);
-    const ScopeContext = scopeInstance.getContext();
-    const loadCurrentUserRequestIdRef = useRef(0);
-    s.meta.scope = scope;
-    s.meta.scopeName = scopeName;
-    const loadCurrentUserFromRequest = useCallback(async () => {
-        // Ignore late current-user responses from discarded mounts so the live provider controls the session state.
-        const requestId = loadCurrentUserRequestIdRef.current + 1;
-        loadCurrentUserRequestIdRef.current = requestId;
-        const { scope } = s.m;
-        const getArgsMethodName = `get${inflection.camelize(scope)}Args`;
+    render() {
+        const { ScopeContext } = this;
+        return (_jsx(ScopeContext.Provider, { value: this.s.result, children: this.p.children }));
+    }
+    loadCurrentUserFromRequest = async () => {
+        // Ignore late current-user responses so the live provider controls session state.
+        const requestId = this.loadCurrentUserRequestId + 1;
+        this.loadCurrentUserRequestId = requestId;
+        const getArgsMethodName = `get${inflection.camelize(this.scope)}Args`;
         const args = Devise[getArgsMethodName]();
-        logger.debug(() => `Loading ${scope} with request`);
-        const result = await Services.current().sendRequest("Devise::Current", { query: args.query, scope });
+        logger.debug(() => `Loading ${this.scope} with request`);
+        const result = await Services.current().sendRequest("Devise::Current", { query: args.query, scope: this.scope });
         const current = digg(result, "current")[0];
-        if (requestId != loadCurrentUserRequestIdRef.current)
+        if (requestId != this.loadCurrentUserRequestId)
             return;
         if (current)
             Devise.updateSession(current);
-        s.set({
-            result: {
-                loaded: true,
-                model: current
-            }
-        });
+        this.setState({ result: { loaded: true, model: current } });
         events.emit("currentUserLoaded", { current });
-    }, []);
-    const defaultCurrentUser = useCallback(() => {
-        const { scope, scopeName } = s.m;
+    };
+    defaultCurrentUser = () => {
         let current;
-        if (Devise.current().hasCurrentScope(s.m.scope)) {
-            current = Devise.current().getCurrentScope(scope);
-            logger.debug(() => `Setting ${scope} from current scope: ${current?.id()}`);
+        if (Devise.current().hasCurrentScope(this.scope)) {
+            current = Devise.current().getCurrentScope(this.scope);
+            logger.debug(() => `Setting ${this.scope} from current scope: ${current?.id()}`);
         }
-        else if (Devise.current().hasGlobalCurrentScope(scope)) {
-            current = Devise[scopeName]();
-            logger.debug(() => `Setting ${scope} from global current scope: ${current?.id()}`);
+        else if (Devise.current().hasGlobalCurrentScope(this.scope)) {
+            current = Devise[this.scopeName]();
+            logger.debug(() => `Setting ${this.scope} from global current scope: ${current?.id()}`);
         }
-        if (current) {
+        if (current)
             events.emit("currentUserLoaded", { current });
-        }
         return current;
-    }, []);
-    s.useStates({
-        result: () => ({
-            loaded: false,
-            model: defaultCurrentUser()
-        })
-    });
-    const updateCurrentUser = useCallback(() => {
-        s.set({
-            result: {
-                loaded: true,
-                model: Devise[s.m.scopeName]()
-            }
-        });
-    }, []);
-    useEffect(() => {
-        if (!Devise.current().hasGlobalCurrentScope(s.m.scope) && !Devise.current().hasCurrentScope(s.m.scope)) {
-            logger.debug(() => `Devise hasn't got current scope ${s.m.scope} so loading from request`);
-            loadCurrentUserFromRequest();
-        }
-        return () => {
-            loadCurrentUserRequestIdRef.current += 1;
-        };
-    }, []);
-    const onDeviseSignIn = useCallback(() => {
-        updateCurrentUser();
-    }, []);
-    const onDeviseSignOut = useCallback(() => {
-        updateCurrentUser();
-    }, []);
-    useEventEmitter(Devise.events(), "onDeviseSignIn", onDeviseSignIn);
-    useEventEmitter(Devise.events(), "onDeviseSignOut", onDeviseSignOut);
-    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":["// @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"]}
+    };
+    updateCurrentUser = () => {
+        this.setState({ result: { loaded: true, model: Devise[this.scopeName]() } });
+    };
+    onDeviseSignIn = () => {
+        // Invalidate any in-flight loadCurrentUserFromRequest — it was dispatched
+        // against the pre-sign-in session and will resolve with current: null,
+        // flipping the context back to signed-out and re-mounting the sign-in
+        // component after we've already applied the signed-in state here.
+        this.loadCurrentUserRequestId += 1;
+        this.updateCurrentUser();
+    };
+    onDeviseSignOut = () => {
+        // Symmetric to onDeviseSignIn: a late response from a request dispatched
+        // before sign-out could otherwise overwrite the signed-out state with a
+        // stale signed-in model.
+        this.loadCurrentUserRequestId += 1;
+        this.updateCurrentUser();
+    };
+}));
+//# 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\nimport * as inflection from \"inflection\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport Devise from \"./devise.js\"\nimport Logger from \"./logger.js\"\nimport PropTypes from \"prop-types\"\nimport React from \"react\"\nimport Services from \"./services.js\"\nimport {digg} from \"diggerize\"\nimport {events} from \"./use-current-user.js\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport propTypesExact from \"prop-types-exact\"\nimport useEventEmitter from \"ya-use-event-emitter\"\nimport useNow from \"set-state-compare/build/use-now.js\"\n\nconst logger = new Logger({name: \"ApiMaker / UseCurrentUserContext\"})\n\n/**\n * @typedef {import(\"./use-current-user.js\").CurrentUserModel} CurrentUserModel\n */\n/**\n * @typedef {object} Result\n * @property {boolean} loaded\n * @property {CurrentUserModel} model\n */\n/**\n * @typedef {object} Props\n * @property {import(\"react\").ReactNode} children\n * @property {string} [scope]\n */\n/**\n * @typedef {object} State\n * @property {Result} result\n */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerUseCurrentUserContext extends ShapeComponent {\n  static propTypes = propTypesExact({\n    children: PropTypes.node,\n    scope: PropTypes.string\n  })\n\n  static defaultProps = {\n    scope: \"user\"\n  }\n\n  state = {\n    result: /** @type {Result} */ ({\n      loaded: false,\n      model: null\n    })\n  }\n\n  loadCurrentUserRequestId = 0\n\n  /** @type {import(\"react\").Context<import(\"./use-current-user.js\").CurrentUserContextValue | undefined>} */\n  ScopeContext\n\n  /** @type {string} */\n  scope\n\n  /** @type {string} */\n  scopeName\n\n  setup() {\n    const scope = this.p.scope ?? \"user\"\n    const scopeName = `current${inflection.camelize(scope)}`\n    const scopeInstance = Devise.getScope(scope)\n\n    this.scope = scope\n    this.scopeName = scopeName\n    this.ScopeContext = scopeInstance.getContext()\n\n    useNow(() => {\n      if (Devise.current().hasCurrentScope(this.scope) || Devise.current().hasGlobalCurrentScope(this.scope)) {\n        this.s.result = {loaded: false, model: this.defaultCurrentUser() ?? null}\n      }\n    }, [])\n\n    React.useEffect(() => {\n      if (!Devise.current().hasGlobalCurrentScope(this.scope) && !Devise.current().hasCurrentScope(this.scope)) {\n        logger.debug(() => `Devise hasn't got current scope ${this.scope} so loading from request`)\n        this.loadCurrentUserFromRequest()\n      }\n\n      // Discard any in-flight current-user load when this instance tears down.\n      return () => {\n        this.loadCurrentUserRequestId += 1\n      }\n    }, [])\n\n    useEventEmitter(Devise.events(), \"onDeviseSignIn\", this.tt.onDeviseSignIn)\n    useEventEmitter(Devise.events(), \"onDeviseSignOut\", this.tt.onDeviseSignOut)\n  }\n\n  render() {\n    const {ScopeContext} = this\n\n    return (\n      <ScopeContext.Provider value={this.s.result}>\n        {this.p.children}\n      </ScopeContext.Provider>\n    )\n  }\n\n  loadCurrentUserFromRequest = async () => {\n    // Ignore late current-user responses so the live provider controls session state.\n    const requestId = this.loadCurrentUserRequestId + 1\n\n    this.loadCurrentUserRequestId = requestId\n\n    const getArgsMethodName = `get${inflection.camelize(this.scope)}Args`\n    const args = Devise[getArgsMethodName]()\n\n    logger.debug(() => `Loading ${this.scope} with request`)\n\n    const result = await Services.current().sendRequest(\"Devise::Current\", {query: args.query, scope: this.scope})\n    const current = digg(result, \"current\")[0]\n\n    if (requestId != this.loadCurrentUserRequestId) return\n\n    if (current) Devise.updateSession(current)\n\n    this.setState({result: {loaded: true, model: current}})\n\n    events.emit(\"currentUserLoaded\", {current})\n  }\n\n  defaultCurrentUser = () => {\n    let current\n\n    if (Devise.current().hasCurrentScope(this.scope)) {\n      current = Devise.current().getCurrentScope(this.scope)\n      logger.debug(() => `Setting ${this.scope} from current scope: ${current?.id()}`)\n    } else if (Devise.current().hasGlobalCurrentScope(this.scope)) {\n      current = Devise[this.scopeName]()\n      logger.debug(() => `Setting ${this.scope} from global current scope: ${current?.id()}`)\n    }\n\n    if (current) events.emit(\"currentUserLoaded\", {current})\n\n    return current\n  }\n\n  updateCurrentUser = () => {\n    this.setState({result: {loaded: true, model: Devise[this.scopeName]()}})\n  }\n\n  onDeviseSignIn = () => {\n    // Invalidate any in-flight loadCurrentUserFromRequest — it was dispatched\n    // against the pre-sign-in session and will resolve with current: null,\n    // flipping the context back to signed-out and re-mounting the sign-in\n    // component after we've already applied the signed-in state here.\n    this.loadCurrentUserRequestId += 1\n    this.updateCurrentUser()\n  }\n\n  onDeviseSignOut = () => {\n    // Symmetric to onDeviseSignIn: a late response from a request dispatched\n    // before sign-out could otherwise overwrite the signed-out state with a\n    // stale signed-in model.\n    this.loadCurrentUserRequestId += 1\n    this.updateCurrentUser()\n  }\n}))\n"]}

package/build/utils/icon.js

@@ -31,7 +31,6 @@ const iconMap = {
  */
 /** @typedef {Record<string, never>} State */
 export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerUtilsIcon extends ShapeComponent {
-    /** @type {Props} */
     static propTypes = {
         color: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
         dataSet: PropTypes.object,
@@ -103,4 +102,4 @@ export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>}
         }
     }
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"icon.js","sourceRoot":"/src/","sources":["utils/icon.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable no-multi-spaces, prefer-object-spread, sort-imports */\nimport FontAwesomeIcon from \"react-native-vector-icons/FontAwesome.js\"\nimport FontAwesome5Icon from \"react-native-vector-icons/FontAwesome5.js\"\nimport FontAwesome6Icon from \"react-native-vector-icons/FontAwesome6.js\"\nimport MaterialIconsIcon from \"react-native-vector-icons/MaterialIcons.js\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport PropTypes from \"prop-types\"\nimport React, {useMemo} from \"react\"\nimport {StyleSheet} from \"react-native\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport {useMergedStyle} from \"./default-style\"\n\nconst FontAwesomeGlyphMap = FontAwesomeIcon.getRawGlyphMap()\nconst FontAwesome5GlyphMap = FontAwesome5Icon.getRawGlyphMap()\nconst FontAwesome6GlyphMap = FontAwesome6Icon.getRawGlyphMap()\nconst MaterialIconsGlyphMap = MaterialIconsIcon.getRawGlyphMap()\n\nconst iconMap = {\n  pencil: \"FontAwesome\",\n  remove: \"FontAwesome\",\n  search: \"FontAwesome\"\n}\n\n/**\n * @typedef {object} Props\n * @property {string|number} [color]\n * @property {object} [dataSet]\n * @property {string} name\n * @property {number} [size]\n * @property {import(\"react-native\").StyleProp<import(\"react-native\").TextStyle>} [style] Only `color` is forwarded.\n * @property {(\"FontAwesome\"|\"FontAwesome5\"|\"FontAwesome6\"|\"MaterialIcons\")} [version]\n */\n/** @typedef {Record<string, never>} State */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerUtilsIcon extends ShapeComponent {\n  /** @type {Props} */\n  static propTypes = {\n    color: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n    dataSet: PropTypes.object,\n    name: PropTypes.string.isRequired,\n    size: PropTypes.number,\n    style: PropTypes.oneOfType([PropTypes.object, PropTypes.array, PropTypes.number]),\n    version: PropTypes.oneOf([\"FontAwesome\", \"FontAwesome5\", \"FontAwesome6\", \"MaterialIcons\"])\n  }\n\n  render() {\n    const {dataSet, name, style, version, ...restProps} = this.props\n    const {stylesList: inheritedStylesList} = useMergedStyle(null, \"Text\")\n    let actualVersion = version\n\n    if (!actualVersion) {\n      if (name in iconMap) {\n        actualVersion = iconMap[name]\n      } else if (name in FontAwesome6GlyphMap) {\n        actualVersion = \"FontAwesome6\"\n      } else if (name in FontAwesome5GlyphMap) {\n        actualVersion = \"FontAwesome5\"\n      } else if (name in FontAwesomeGlyphMap) {\n        actualVersion = \"FontAwesome\"\n      } else if (name in MaterialIconsGlyphMap) {\n        actualVersion =  \"MaterialIcons\"\n      } else {\n        actualVersion = \"FontAwesome\"\n      }\n    }\n\n    // Only forward some styles like color from inherited Text styles.\n    const actualStylesList = useMemo(() => {\n      const actualStylesList = []\n\n      for (const inheritedStyle of inheritedStylesList) {\n        const flattenedStyle = StyleSheet.flatten(inheritedStyle) || {}\n\n        if (\"color\" in flattenedStyle) {\n          actualStylesList.push({color: flattenedStyle.color})\n        }\n      }\n\n      if (Array.isArray(style)) {\n        for (const propStyle of style) {\n          if (propStyle) {\n            actualStylesList.push(propStyle)\n          }\n        }\n      } else if (style) {\n        actualStylesList.push(style)\n      }\n\n      return actualStylesList\n    }, [inheritedStylesList, style])\n\n    const actualDataSet = useMemo(() => Object.assign({name, version: actualVersion}, dataSet), [actualVersion, dataSet, name])\n\n    if (actualVersion == \"FontAwesome\") {\n      return <FontAwesomeIcon dataSet={actualDataSet} name={name} style={actualStylesList} {...restProps} />\n    } else if (actualVersion == \"FontAwesome5\") {\n      return <FontAwesome5Icon dataSet={actualDataSet} name={name} style={actualStylesList} {...restProps} />\n    } else if (actualVersion == \"FontAwesome6\") {\n      return <FontAwesome6Icon dataSet={actualDataSet} name={name} style={actualStylesList} {...restProps} />\n    } else if (actualVersion == \"MaterialIcons\") {\n      return <MaterialIconsIcon dataSet={actualDataSet} name={name} style={actualStylesList} {...restProps} />\n    } else {\n      throw new Error(`Unknown version: ${actualVersion}`)\n    }\n  }\n}))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"icon.js","sourceRoot":"/src/","sources":["utils/icon.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable no-multi-spaces, prefer-object-spread, sort-imports */\nimport FontAwesomeIcon from \"react-native-vector-icons/FontAwesome.js\"\nimport FontAwesome5Icon from \"react-native-vector-icons/FontAwesome5.js\"\nimport FontAwesome6Icon from \"react-native-vector-icons/FontAwesome6.js\"\nimport MaterialIconsIcon from \"react-native-vector-icons/MaterialIcons.js\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport PropTypes from \"prop-types\"\nimport React, {useMemo} from \"react\"\nimport {StyleSheet} from \"react-native\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport {useMergedStyle} from \"./default-style\"\n\nconst FontAwesomeGlyphMap = FontAwesomeIcon.getRawGlyphMap()\nconst FontAwesome5GlyphMap = FontAwesome5Icon.getRawGlyphMap()\nconst FontAwesome6GlyphMap = FontAwesome6Icon.getRawGlyphMap()\nconst MaterialIconsGlyphMap = MaterialIconsIcon.getRawGlyphMap()\n\nconst iconMap = {\n  pencil: \"FontAwesome\",\n  remove: \"FontAwesome\",\n  search: \"FontAwesome\"\n}\n\n/**\n * @typedef {object} Props\n * @property {string|number} [color]\n * @property {object} [dataSet]\n * @property {string} name\n * @property {number} [size]\n * @property {import(\"react-native\").StyleProp<import(\"react-native\").TextStyle>} [style] Only `color` is forwarded.\n * @property {(\"FontAwesome\"|\"FontAwesome5\"|\"FontAwesome6\"|\"MaterialIcons\")} [version]\n */\n/** @typedef {Record<string, never>} State */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class ApiMakerUtilsIcon extends ShapeComponent {\n  static propTypes = {\n    color: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n    dataSet: PropTypes.object,\n    name: PropTypes.string.isRequired,\n    size: PropTypes.number,\n    style: PropTypes.oneOfType([PropTypes.object, PropTypes.array, PropTypes.number]),\n    version: PropTypes.oneOf([\"FontAwesome\", \"FontAwesome5\", \"FontAwesome6\", \"MaterialIcons\"])\n  }\n\n  render() {\n    const {dataSet, name, style, version, ...restProps} = this.props\n    const {stylesList: inheritedStylesList} = useMergedStyle(null, \"Text\")\n    let actualVersion = version\n\n    if (!actualVersion) {\n      if (name in iconMap) {\n        actualVersion = iconMap[name]\n      } else if (name in FontAwesome6GlyphMap) {\n        actualVersion = \"FontAwesome6\"\n      } else if (name in FontAwesome5GlyphMap) {\n        actualVersion = \"FontAwesome5\"\n      } else if (name in FontAwesomeGlyphMap) {\n        actualVersion = \"FontAwesome\"\n      } else if (name in MaterialIconsGlyphMap) {\n        actualVersion =  \"MaterialIcons\"\n      } else {\n        actualVersion = \"FontAwesome\"\n      }\n    }\n\n    // Only forward some styles like color from inherited Text styles.\n    const actualStylesList = useMemo(() => {\n      const actualStylesList = []\n\n      for (const inheritedStyle of inheritedStylesList) {\n        const flattenedStyle = StyleSheet.flatten(inheritedStyle) || {}\n\n        if (\"color\" in flattenedStyle) {\n          actualStylesList.push({color: flattenedStyle.color})\n        }\n      }\n\n      if (Array.isArray(style)) {\n        for (const propStyle of style) {\n          if (propStyle) {\n            actualStylesList.push(propStyle)\n          }\n        }\n      } else if (style) {\n        actualStylesList.push(style)\n      }\n\n      return actualStylesList\n    }, [inheritedStylesList, style])\n\n    const actualDataSet = useMemo(() => Object.assign({name, version: actualVersion}, dataSet), [actualVersion, dataSet, name])\n\n    if (actualVersion == \"FontAwesome\") {\n      return <FontAwesomeIcon dataSet={actualDataSet} name={name} style={actualStylesList} {...restProps} />\n    } else if (actualVersion == \"FontAwesome5\") {\n      return <FontAwesome5Icon dataSet={actualDataSet} name={name} style={actualStylesList} {...restProps} />\n    } else if (actualVersion == \"FontAwesome6\") {\n      return <FontAwesome6Icon dataSet={actualDataSet} name={name} style={actualStylesList} {...restProps} />\n    } else if (actualVersion == \"MaterialIcons\") {\n      return <MaterialIconsIcon dataSet={actualDataSet} name={name} style={actualStylesList} {...restProps} />\n    } else {\n      throw new Error(`Unknown version: ${actualVersion}`)\n    }\n  }\n}))\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kaspernj/api-maker",
   "type": "module",
-  "version": "1.0.2165",
+  "version": "1.0.2167",
   "description": "My new module",
   "files": [
     "build/**"
@@ -73,11 +73,12 @@
     "ya-use-event-listener": ">= 0.1.1"
   },
   "devDependencies": {
-    "@eslint/js": "^10.0.1",
     "@babel/preset-env": "^7.12.11",
     "@babel/preset-react": "^7.26.3",
     "@eslint/compat": "^2.0.3",
+    "@eslint/js": "^10.0.1",
     "@jest/globals": "~30.3.0",
+    "@types/prop-types": "^15.7.15",
     "@types/react": "~19.0.10",
     "babel-jest": "~30.3.0",
     "eslint": "^10.2.1",