@kaspernj/api-maker 1.0.2166 → 1.0.2168

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

@@ -1,11 +1,8 @@
 export default class ApiMakerBootstrapInvalidFeedback extends React.PureComponent<any, any, any> {
-    static propTypes: PropTypes.ValidationMap<{
-        errors: any[];
-    }>;
+    static propTypes: ValidationMap<T>;
     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;;OAEE;;IAEF,kDAMC;IAED,uBAWC;CACF;kBA3BiB,OAAO;sBAFH,YAAY"}
+{"version":3,"file":"invalid-feedback.d.ts","sourceRoot":"/src/","sources":["bootstrap/invalid-feedback.jsx"],"names":[],"mappings":"AAMA;IACE,mCAEE;;IAEF,kDAMC;IAED,uBAWC;CACF;kBA3BiB,OAAO"}

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

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":"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"}

package/build/devise.js

@@ -105,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)
@@ -117,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,
@@ -153,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;
     }
@@ -295,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  /**\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 | 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,12 +2,7 @@ export default class ApiMakerEventConnection extends React.PureComponent<any, an
     static defaultProps: {
         active: boolean;
     };
-    static propTypes: PropTypes.ValidationMap<{
-        active: boolean;
-        model: object;
-        event: string;
-        onCall: (...args: any[]) => any;
-    }>;
+    static propTypes: ValidationMap<T>;
     constructor(props: any);
     componentDidMount(): void;
     subscription: import("./cable-subscription.js").default;
@@ -16,5 +11,4 @@ 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;;;;;OAKE;;IAEF,0BAEC;IADC,wDAA8G;IAGhH,6BAIC;IAED,cAEC;IAED,6BAIC;CACF;kBAlCiB,OAAO;sBADH,YAAY"}
+{"version":3,"file":"event-connection.d.ts","sourceRoot":"/src/","sources":["event-connection.jsx"],"names":[],"mappings":"AAMA;IACE;;MAEC;IAED,mCAKE;;IAEF,0BAEC;IADC,wDAA8G;IAGhH,6BAIC;IAED,cAEC;IAED,6BAIC;CACF;kBAlCiB,OAAO"}

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

@@ -1,9 +1,5 @@
 export default class ApiMakerEventModelClass extends React.PureComponent<any, any, any> {
-    static propTypes: PropTypes.ValidationMap<{
-        event: string;
-        modelClass: (...args: any[]) => any;
-        onCall: (...args: any[]) => any;
-    }>;
+    static propTypes: ValidationMap<T>;
     constructor(props: any);
     componentDidMount(): void;
     componentWillUnmount(): void;
@@ -12,5 +8,4 @@ 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;;;;OAIE;;IAEF,0BAEC;IAED,6BAIC;IAED,gBAEC;IADC,sDAA2G;IAG7G,cAEC;CACF;kBA3BiB,OAAO;sBADH,YAAY"}
+{"version":3,"file":"event-model-class.d.ts","sourceRoot":"/src/","sources":["event-model-class.jsx"],"names":[],"mappings":"AAMA;IACE,mCAIE;;IAEF,0BAEC;IAED,6BAIC;IAED,gBAEC;IADC,sDAA2G;IAG7G,cAEC;CACF;kBA3BiB,OAAO"}

package/build/updated-attribute.d.ts

@@ -1,9 +1,5 @@
 export default class ApiMakerUpdatedAttribute extends React.PureComponent<any, any, any> {
-    static propTypes: PropTypes.ValidationMap<{
-        attribute: string;
-        model: object;
-        onValue: (...args: any[]) => any;
-    }>;
+    static propTypes: ValidationMap<T>;
     constructor(props: any);
     state: {
         model: any;
@@ -17,5 +13,4 @@ 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;;;;OAIE;IAEF,wBAKC;IAHC;;MAEC;IAGH,0BAGC;IAED,6BAKC;IAED,gBAWC;IAVC,0DASE;IAIJ,wCAqBC;IAED,qBAgBC;IAED,cAIC;CACF;kBAxFiB,OAAO;sBAFH,YAAY"}
+{"version":3,"file":"updated-attribute.d.ts","sourceRoot":"/src/","sources":["updated-attribute.jsx"],"names":[],"mappings":"AAQA;IACE,mCAIE;IAEF,wBAKC;IAHC;;MAEC;IAGH,0BAGC;IAED,6BAKC;IAED,gBAWC;IAVC,0DASE;IAIJ,wCAqBC;IAED,qBAgBC;IAED,cAIC;CACF;kBAxFiB,OAAO"}

package/build/utils/default-style.d.ts

@@ -4,12 +4,20 @@ export type WithDefaultStyleProps = {
     children?: React.ReactNode;
     style: DefaultStyleMap;
 };
+/**
+ * Pure helper: collapse the inherited default for a slot plus the caller's
+ * style into a flat list ready to pass to the underlying RN element.
+ * @param {DefaultStyleValue | undefined} defaultElementStyle
+ * @param {DefaultStyleValue | undefined} style
+ * @returns {DefaultStyleValue[]}
+ */
+export function computeSlotStylesList(defaultElementStyle: DefaultStyleValue | undefined, style: DefaultStyleValue | undefined): DefaultStyleValue[];
 export function useDefaultStyle(): DefaultStyleMap;
 export function useMergedStyle(style: any, elementType: any): {
     newDefaultStyle: {
         [x: string]: DefaultStyleValue;
     };
-    stylesList: (import("react-native").ViewStyle | import("react-native").Falsy | import("react-native").ImageStyle | import("react-native").TextStyle | import("react-native").RegisteredStyle<import("react-native").ViewStyle | import("react-native").ImageStyle | import("react-native").TextStyle> | import("react-native").RecursiveArray<import("react-native").ViewStyle | import("react-native").Falsy | import("react-native").ImageStyle | import("react-native").TextStyle | import("react-native").RegisteredStyle<import("react-native").ViewStyle | import("react-native").ImageStyle | import("react-native").TextStyle>> | readonly (import("react-native").ViewStyle | import("react-native").Falsy | import("react-native").ImageStyle | import("react-native").TextStyle | import("react-native").RegisteredStyle<import("react-native").ViewStyle | import("react-native").ImageStyle | import("react-native").TextStyle>)[])[];
+    stylesList: DefaultStyleValue[];
 };
 export const WithDefaultStyle: React.NamedExoticComponent<WithDefaultStyleProps>;
 import React from "react";

package/build/utils/default-style.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"default-style.d.ts","sourceRoot":"/src/","sources":["utils/default-style.jsx"],"names":[],"mappings":"gCAMa,OAAO,cAAc,EAAE,SAAS,CAC5C,OAAW,cAAc,EAAE,SAAS,GAAG,OAAO,cAAc,EAAE,SAAS,GAAG,OAAO,cAAc,EAAE,UAAU,CACxG;8BAEU,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC;oCACjC;IAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAC;AAMlE,mDAIC;AAED;;;;;EAmCC;AAED,iFA2BE;kBAtFsD,OAAO"}
+{"version":3,"file":"default-style.d.ts","sourceRoot":"/src/","sources":["utils/default-style.jsx"],"names":[],"mappings":"gCAMa,OAAO,cAAc,EAAE,SAAS,CAC5C,OAAW,cAAc,EAAE,SAAS,GAAG,OAAO,cAAc,EAAE,SAAS,GAAG,OAAO,cAAc,EAAE,UAAU,CACxG;8BAEU,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC;oCACjC;IAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAC;AAUlE;;;;;;GAMG;AACH,2DAJW,iBAAiB,GAAG,SAAS,SAC7B,iBAAiB,GAAG,SAAS,GAC3B,iBAAiB,EAAE,CAsB/B;AAjCD,mDAIC;AA+BD;;;;;EAiBC;AAED,iFAoBE;kBAxFsD,OAAO"}

package/build/utils/default-style.js

@@ -10,37 +10,42 @@ import memo from "set-state-compare/build/memo.js";
  */
 /** @typedef {Record<string, DefaultStyleValue>} DefaultStyleMap */
 /** @typedef {{children?: React.ReactNode, style: DefaultStyleMap}} WithDefaultStyleProps */
-const DefaultStyleContext = createContext(/** @type {DefaultStyleMap} */ ({
-    Text: []
-}));
+const DefaultStyleContext = createContext(/** @type {DefaultStyleMap} */ ({}));
 const useDefaultStyle = () => {
     const defaultStyle = useContext(DefaultStyleContext);
     return defaultStyle;
 };
+/**
+ * Pure helper: collapse the inherited default for a slot plus the caller's
+ * style into a flat list ready to pass to the underlying RN element.
+ * @param {DefaultStyleValue | undefined} defaultElementStyle
+ * @param {DefaultStyleValue | undefined} style
+ * @returns {DefaultStyleValue[]}
+ */
+const computeSlotStylesList = (defaultElementStyle, style) => {
+    let stylesList;
+    if (defaultElementStyle === undefined || defaultElementStyle === null) {
+        stylesList = [];
+    }
+    else if (Array.isArray(defaultElementStyle)) {
+        stylesList = [...defaultElementStyle];
+    }
+    else {
+        stylesList = [defaultElementStyle];
+    }
+    if (style && Array.isArray(style)) {
+        for (const styleI of style) {
+            stylesList.push(styleI);
+        }
+    }
+    else if (style) {
+        stylesList.push(style);
+    }
+    return stylesList;
+};
 const useMergedStyle = (style, elementType) => {
     const defaultStyle = useDefaultStyle();
-    const stylesList = useMemo(() => {
-        const defaultElementStyle = defaultStyle[elementType];
-        let stylesList;
-        if (Array.isArray(defaultElementStyle)) {
-            stylesList = [...defaultElementStyle];
-        }
-        else if (typeof defaultElementStyle == "object") {
-            stylesList = [defaultElementStyle];
-        }
-        else {
-            throw new Error(`Unknown type for default element type: ${typeof defaultElementStyle}`);
-        }
-        if (style && Array.isArray(style)) {
-            for (const styleI of style) {
-                stylesList.push(styleI);
-            }
-        }
-        else if (style) {
-            stylesList.push(style);
-        }
-        return stylesList;
-    }, [defaultStyle, elementType, style]);
+    const stylesList = useMemo(() => computeSlotStylesList(defaultStyle[elementType], style), [defaultStyle, elementType, style]);
     const actualNewDefaultStyle = useMemo(() => {
         const actualNewDefaultStyle = { ...defaultStyle };
         actualNewDefaultStyle[elementType] = stylesList;
@@ -54,17 +59,11 @@ const WithDefaultStyle = memo((/** @type {WithDefaultStyleProps} */ { children,
     }
     const defaultStyle = useContext(DefaultStyleContext);
     const newDefaultStyle = useMemo(() => {
-        for (const key in style) {
-            if (!(key in defaultStyle)) {
-                throw new Error(`Invalid element type given: ${key}`);
-            }
-        }
-        /** @type {DefaultStyleMap} */
-        const newDefaultStyle = {};
+        const newDefaultStyle = /** @type {DefaultStyleMap} */ ({});
         incorporate(newDefaultStyle, defaultStyle, style);
         return newDefaultStyle;
     }, [defaultStyle, style]);
     return (_jsx(DefaultStyleContext.Provider, { value: newDefaultStyle, children: children }));
 });
-export { useDefaultStyle, useMergedStyle, WithDefaultStyle };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1zdHlsZS5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsidXRpbHMvZGVmYXVsdC1zdHlsZS5qc3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFlBQVk7QUFDWixPQUFPLEtBQUssRUFBRSxFQUFDLGFBQWEsRUFBRSxVQUFVLEVBQUUsT0FBTyxFQUFDLE1BQU0sT0FBTyxDQUFBO0FBQy9ELE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSxjQUFjLENBQUE7QUFDeEMsT0FBTyxJQUFJLE1BQU0saUNBQWlDLENBQUE7QUFFbEQ7Ozs7R0FJRztBQUNILG1FQUFtRTtBQUNuRSw0RkFBNEY7QUFFNUYsTUFBTSxtQkFBbUIsR0FBRyxhQUFhLENBQUMsOEJBQThCLENBQUMsQ0FBQztJQUN4RSxJQUFJLEVBQUUsRUFBRTtDQUNULENBQUMsQ0FBQyxDQUFBO0FBRUgsTUFBTSxlQUFlLEdBQUcsR0FBRyxFQUFFO0lBQzNCLE1BQU0sWUFBWSxHQUFHLFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFBO0lBRXBELE9BQU8sWUFBWSxDQUFBO0FBQ3JCLENBQUMsQ0FBQTtBQUVELE1BQU0sY0FBYyxHQUFHLENBQUMsS0FBSyxFQUFFLFdBQVcsRUFBRSxFQUFFO0lBQzVDLE1BQU0sWUFBWSxHQUFHLGVBQWUsRUFBRSxDQUFBO0lBRXRDLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxHQUFHLEVBQUU7UUFDOUIsTUFBTSxtQkFBbUIsR0FBRyxZQUFZLENBQUMsV0FBVyxDQUFDLENBQUE7UUFDckQsSUFBSSxVQUFVLENBQUE7UUFFZCxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsbUJBQW1CLENBQUMsRUFBRSxDQUFDO1lBQ3ZDLFVBQVUsR0FBRyxDQUFDLEdBQUcsbUJBQW1CLENBQUMsQ0FBQTtRQUN2QyxDQUFDO2FBQU0sSUFBSSxPQUFPLG1CQUFtQixJQUFJLFFBQVEsRUFBRSxDQUFDO1lBQ2xELFVBQVUsR0FBRyxDQUFDLG1CQUFtQixDQUFDLENBQUE7UUFDcEMsQ0FBQzthQUFNLENBQUM7WUFDTixNQUFNLElBQUksS0FBSyxDQUFDLDBDQUEwQyxPQUFPLG1CQUFtQixFQUFFLENBQUMsQ0FBQTtRQUN6RixDQUFDO1FBRUQsSUFBSSxLQUFLLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ2xDLEtBQUssTUFBTSxNQUFNLElBQUksS0FBSyxFQUFFLENBQUM7Z0JBQzNCLFVBQVUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUE7WUFDekIsQ0FBQztRQUNILENBQUM7YUFBTSxJQUFJLEtBQUssRUFBRSxDQUFDO1lBQ2pCLFVBQVUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDeEIsQ0FBQztRQUVELE9BQU8sVUFBVSxDQUFBO0lBQ25CLENBQUMsRUFBRSxDQUFDLFlBQVksRUFBRSxXQUFXLEVBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQTtJQUV0QyxNQUFNLHFCQUFxQixHQUFHLE9BQU8sQ0FBQyxHQUFHLEVBQUU7UUFDekMsTUFBTSxxQkFBcUIsR0FBRyxFQUFDLEdBQUcsWUFBWSxFQUFDLENBQUE7UUFFL0MscUJBQXFCLENBQUMsV0FBVyxDQUFDLEdBQUcsVUFBVSxDQUFBO1FBRS9DLE9BQU8scUJBQXFCLENBQUE7SUFDOUIsQ0FBQyxFQUFFLENBQUMsWUFBWSxFQUFFLFdBQVcsRUFBRSxVQUFVLENBQUMsQ0FBQyxDQUFBO0lBRTNDLE9BQU8sRUFBQyxlQUFlLEVBQUUscUJBQXFCLEVBQUUsVUFBVSxFQUFDLENBQUE7QUFDN0QsQ0FBQyxDQUFBO0FBRUQsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsQ0FBQyxvQ0FBb0MsQ0FBQyxFQUFDLFFBQVEsRUFBRSxLQUFLLEVBQUUsR0FBRyxTQUFTLEVBQUMsRUFBRSxFQUFFO0lBQ3JHLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDdEMsTUFBTSxJQUFJLEtBQUssQ0FBQyxvQkFBb0IsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFBO0lBQzFFLENBQUM7SUFFRCxNQUFNLFlBQVksR0FBRyxVQUFVLENBQUMsbUJBQW1CLENBQUMsQ0FBQTtJQUVwRCxNQUFNLGVBQWUsR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFO1FBQ25DLEtBQUssTUFBTSxHQUFHLElBQUksS0FBSyxFQUFFLENBQUM7WUFDeEIsSUFBSSxDQUFDLENBQUMsR0FBRyxJQUFJLFlBQVksQ0FBQyxFQUFFLENBQUM7Z0JBQzNCLE1BQU0sSUFBSSxLQUFLLENBQUMsK0JBQStCLEdBQUcsRUFBRSxDQUFDLENBQUE7WUFDdkQsQ0FBQztRQUNILENBQUM7UUFFRCw4QkFBOEI7UUFDOUIsTUFBTSxlQUFlLEdBQUcsRUFBRSxDQUFBO1FBRTFCLFdBQVcsQ0FBQyxlQUFlLEVBQUUsWUFBWSxFQUFFLEtBQUssQ0FBQyxDQUFBO1FBRWpELE9BQU8sZUFBZSxDQUFBO0lBQ3hCLENBQUMsRUFBRSxDQUFDLFlBQVksRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFBO0lBRXpCLE9BQU8sQ0FDTCxLQUFDLG1CQUFtQixDQUFDLFFBQVEsSUFBQyxLQUFLLEVBQUUsZUFBZSxZQUNqRCxRQUFRLEdBQ29CLENBQ2hDLENBQUE7QUFDSCxDQUFDLENBQUMsQ0FBQTtBQUVGLE9BQU8sRUFBQyxlQUFlLEVBQUUsY0FBYyxFQUFFLGdCQUFnQixFQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcbmltcG9ydCBSZWFjdCwge2NyZWF0ZUNvbnRleHQsIHVzZUNvbnRleHQsIHVzZU1lbW99IGZyb20gXCJyZWFjdFwiXG5pbXBvcnQge2luY29ycG9yYXRlfSBmcm9tIFwiaW5jb3Jwb3JhdG9yXCJcbmltcG9ydCBtZW1vIGZyb20gXCJzZXQtc3RhdGUtY29tcGFyZS9idWlsZC9tZW1vLmpzXCJcblxuLyoqXG4gKiBAdHlwZWRlZiB7aW1wb3J0KFwicmVhY3QtbmF0aXZlXCIpLlN0eWxlUHJvcDxcbiAqICAgaW1wb3J0KFwicmVhY3QtbmF0aXZlXCIpLlRleHRTdHlsZSB8IGltcG9ydChcInJlYWN0LW5hdGl2ZVwiKS5WaWV3U3R5bGUgfCBpbXBvcnQoXCJyZWFjdC1uYXRpdmVcIikuSW1hZ2VTdHlsZVxuICogPn0gRGVmYXVsdFN0eWxlVmFsdWVcbiAqL1xuLyoqIEB0eXBlZGVmIHtSZWNvcmQ8c3RyaW5nLCBEZWZhdWx0U3R5bGVWYWx1ZT59IERlZmF1bHRTdHlsZU1hcCAqL1xuLyoqIEB0eXBlZGVmIHt7Y2hpbGRyZW4/OiBSZWFjdC5SZWFjdE5vZGUsIHN0eWxlOiBEZWZhdWx0U3R5bGVNYXB9fSBXaXRoRGVmYXVsdFN0eWxlUHJvcHMgKi9cblxuY29uc3QgRGVmYXVsdFN0eWxlQ29udGV4dCA9IGNyZWF0ZUNvbnRleHQoLyoqIEB0eXBlIHtEZWZhdWx0U3R5bGVNYXB9ICovICh7XG4gIFRleHQ6IFtdXG59KSlcblxuY29uc3QgdXNlRGVmYXVsdFN0eWxlID0gKCkgPT4ge1xuICBjb25zdCBkZWZhdWx0U3R5bGUgPSB1c2VDb250ZXh0KERlZmF1bHRTdHlsZUNvbnRleHQpXG5cbiAgcmV0dXJuIGRlZmF1bHRTdHlsZVxufVxuXG5jb25zdCB1c2VNZXJnZWRTdHlsZSA9IChzdHlsZSwgZWxlbWVudFR5cGUpID0+IHtcbiAgY29uc3QgZGVmYXVsdFN0eWxlID0gdXNlRGVmYXVsdFN0eWxlKClcblxuICBjb25zdCBzdHlsZXNMaXN0ID0gdXNlTWVtbygoKSA9PiB7XG4gICAgY29uc3QgZGVmYXVsdEVsZW1lbnRTdHlsZSA9IGRlZmF1bHRTdHlsZVtlbGVtZW50VHlwZV1cbiAgICBsZXQgc3R5bGVzTGlzdFxuXG4gICAgaWYgKEFycmF5LmlzQXJyYXkoZGVmYXVsdEVsZW1lbnRTdHlsZSkpIHtcbiAgICAgIHN0eWxlc0xpc3QgPSBbLi4uZGVmYXVsdEVsZW1lbnRTdHlsZV1cbiAgICB9IGVsc2UgaWYgKHR5cGVvZiBkZWZhdWx0RWxlbWVudFN0eWxlID09IFwib2JqZWN0XCIpIHtcbiAgICAgIHN0eWxlc0xpc3QgPSBbZGVmYXVsdEVsZW1lbnRTdHlsZV1cbiAgICB9IGVsc2Uge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKGBVbmtub3duIHR5cGUgZm9yIGRlZmF1bHQgZWxlbWVudCB0eXBlOiAke3R5cGVvZiBkZWZhdWx0RWxlbWVudFN0eWxlfWApXG4gICAgfVxuXG4gICAgaWYgKHN0eWxlICYmIEFycmF5LmlzQXJyYXkoc3R5bGUpKSB7XG4gICAgICBmb3IgKGNvbnN0IHN0eWxlSSBvZiBzdHlsZSkge1xuICAgICAgICBzdHlsZXNMaXN0LnB1c2goc3R5bGVJKVxuICAgICAgfVxuICAgIH0gZWxzZSBpZiAoc3R5bGUpIHtcbiAgICAgIHN0eWxlc0xpc3QucHVzaChzdHlsZSlcbiAgICB9XG5cbiAgICByZXR1cm4gc3R5bGVzTGlzdFxuICB9LCBbZGVmYXVsdFN0eWxlLCBlbGVtZW50VHlwZSwgc3R5bGVdKVxuXG4gIGNvbnN0IGFjdHVhbE5ld0RlZmF1bHRTdHlsZSA9IHVzZU1lbW8oKCkgPT4ge1xuICAgIGNvbnN0IGFjdHVhbE5ld0RlZmF1bHRTdHlsZSA9IHsuLi5kZWZhdWx0U3R5bGV9XG5cbiAgICBhY3R1YWxOZXdEZWZhdWx0U3R5bGVbZWxlbWVudFR5cGVdID0gc3R5bGVzTGlzdFxuXG4gICAgcmV0dXJuIGFjdHVhbE5ld0RlZmF1bHRTdHlsZVxuICB9LCBbZGVmYXVsdFN0eWxlLCBlbGVtZW50VHlwZSwgc3R5bGVzTGlzdF0pXG5cbiAgcmV0dXJuIHtuZXdEZWZhdWx0U3R5bGU6IGFjdHVhbE5ld0RlZmF1bHRTdHlsZSwgc3R5bGVzTGlzdH1cbn1cblxuY29uc3QgV2l0aERlZmF1bHRTdHlsZSA9IG1lbW8oKC8qKiBAdHlwZSB7V2l0aERlZmF1bHRTdHlsZVByb3BzfSAqLyB7Y2hpbGRyZW4sIHN0eWxlLCAuLi5yZXN0UHJvcHN9KSA9PiB7XG4gIGlmIChPYmplY3Qua2V5cyhyZXN0UHJvcHMpLmxlbmd0aCA+IDApIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYFVuaGFuZGxlZCBwcm9wczogJHtPYmplY3Qua2V5cyhyZXN0UHJvcHMpLmpvaW4oXCIsIFwiKX1gKVxuICB9XG5cbiAgY29uc3QgZGVmYXVsdFN0eWxlID0gdXNlQ29udGV4dChEZWZhdWx0U3R5bGVDb250ZXh0KVxuXG4gIGNvbnN0IG5ld0RlZmF1bHRTdHlsZSA9IHVzZU1lbW8oKCkgPT4ge1xuICAgIGZvciAoY29uc3Qga2V5IGluIHN0eWxlKSB7XG4gICAgICBpZiAoIShrZXkgaW4gZGVmYXVsdFN0eWxlKSkge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYEludmFsaWQgZWxlbWVudCB0eXBlIGdpdmVuOiAke2tleX1gKVxuICAgICAgfVxuICAgIH1cblxuICAgIC8qKiBAdHlwZSB7RGVmYXVsdFN0eWxlTWFwfSAqL1xuICAgIGNvbnN0IG5ld0RlZmF1bHRTdHlsZSA9IHt9XG5cbiAgICBpbmNvcnBvcmF0ZShuZXdEZWZhdWx0U3R5bGUsIGRlZmF1bHRTdHlsZSwgc3R5bGUpXG5cbiAgICByZXR1cm4gbmV3RGVmYXVsdFN0eWxlXG4gIH0sIFtkZWZhdWx0U3R5bGUsIHN0eWxlXSlcblxuICByZXR1cm4gKFxuICAgIDxEZWZhdWx0U3R5bGVDb250ZXh0LlByb3ZpZGVyIHZhbHVlPXtuZXdEZWZhdWx0U3R5bGV9PlxuICAgICAge2NoaWxkcmVufVxuICAgIDwvRGVmYXVsdFN0eWxlQ29udGV4dC5Qcm92aWRlcj5cbiAgKVxufSlcblxuZXhwb3J0IHt1c2VEZWZhdWx0U3R5bGUsIHVzZU1lcmdlZFN0eWxlLCBXaXRoRGVmYXVsdFN0eWxlfVxuIl19
+export { computeSlotStylesList, useDefaultStyle, useMergedStyle, WithDefaultStyle };
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/text-input.d.ts

@@ -0,0 +1,27 @@
+export default ApiMakerUtilsTextInput;
+export type TextInputProps = import("react-native").TextInputProps & {
+    style?: import("react-native").StyleProp<import("react-native").TextStyle>;
+};
+/**
+ * @typedef {import("react-native").TextInputProps & {
+ *   style?: import("react-native").StyleProp<import("react-native").TextStyle>
+ * }} TextInputProps
+ */
+/**
+ * RN TextInput wired into the api-maker default-style context under the
+ * `"TextInput"` slot. RN's `TextInput` does not subscribe to the api-maker
+ * `Text` slot, so apps that want consistent text colour and font sizing for
+ * inputs need this wrapper alongside `<Text>`.
+ *
+ * Wrap the consumer tree once and inputs pick up the defaults:
+ *
+ * ```jsx
+ * <WithDefaultStyle style={{TextInput: {color: colors.text, fontSize: 14}}}>
+ *   <TextInput value={value} onChangeText={onChange} />
+ * </WithDefaultStyle>
+ * ```
+ */
+declare const ApiMakerUtilsTextInput: React.MemoExoticComponent<React.ForwardRefExoticComponent<TextInputProps & React.RefAttributes<RnTextInput>>>;
+import React from "react";
+import { TextInput as RnTextInput } from "react-native";
+//# sourceMappingURL=text-input.d.ts.map

package/build/utils/text-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-input.d.ts","sourceRoot":"/src/","sources":["utils/text-input.jsx"],"names":[],"mappings":";6BAMa,OAAO,cAAc,EAAE,cAAc,GAAG;IAChD,KAAK,CAAC,EAAE,OAAO,cAAc,EAAE,SAAS,CAAC,OAAO,cAAc,EAAE,SAAS,CAAC,CAAA;CAC3E;AAHJ;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,sCAA0C,KAAK,CAAC,mBAAmB,CAAC,KAAK,CAAC,yBAAyB,CAAC,cAAc,GAAG,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC,CAKtJ;kBA7BiB,OAAO;yCACc,cAAc"}

package/build/utils/text-input.js

@@ -0,0 +1,27 @@
+// @ts-check
+import React from "react";
+import { TextInput as RnTextInput } from "react-native";
+import withDefaultStyleSlot from "./with-default-style-slot";
+/**
+ * @typedef {import("react-native").TextInputProps & {
+ *   style?: import("react-native").StyleProp<import("react-native").TextStyle>
+ * }} TextInputProps
+ */
+/**
+ * RN TextInput wired into the api-maker default-style context under the
+ * `"TextInput"` slot. RN's `TextInput` does not subscribe to the api-maker
+ * `Text` slot, so apps that want consistent text colour and font sizing for
+ * inputs need this wrapper alongside `<Text>`.
+ *
+ * Wrap the consumer tree once and inputs pick up the defaults:
+ *
+ * ```jsx
+ * <WithDefaultStyle style={{TextInput: {color: colors.text, fontSize: 14}}}>
+ *   <TextInput value={value} onChangeText={onChange} />
+ * </WithDefaultStyle>
+ * ```
+ */
+const ApiMakerUtilsTextInput = /** @type {React.MemoExoticComponent<React.ForwardRefExoticComponent<TextInputProps & React.RefAttributes<RnTextInput>>>} */ (withDefaultStyleSlot(
+/** @type {React.ComponentType<TextInputProps>} */ (RnTextInput), "TextInput"));
+export default ApiMakerUtilsTextInput;
+//# sourceMappingURL=data:application/json;base64,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

package/build/utils/with-default-style-slot.d.ts

@@ -0,0 +1,28 @@
+export default withDefaultStyleSlot;
+/**
+ * Wires `Component` into the api-maker default-style context as a slot.
+ * Inherits accumulated defaults for `slotKey`, merges them with the caller's
+ * `style` prop, and re-provides the merged list so nested instances of the
+ * same component continue to inherit.
+ *
+ * Caller usage mirrors the built-in `Text` wrapper:
+ *
+ * ```jsx
+ * import {Link as ExpoLink} from "expo-router"
+ * import withDefaultStyleSlot from "@kaspernj/api-maker/build/utils/with-default-style-slot"
+ *
+ * const Link = withDefaultStyleSlot(ExpoLink, "Link")
+ *
+ * // …consumer tree wraps in <WithDefaultStyle style={{Link: {color: "red"}}}> …
+ * ```
+ *
+ * @template {object} P
+ * @template T
+ * @param {React.ComponentType<P> | React.ForwardRefExoticComponent<P & React.RefAttributes<T>>} Component
+ *   Underlying component to wrap.
+ * @param {string} slotKey Slot name to register defaults under.
+ * @returns {React.MemoExoticComponent<React.ForwardRefExoticComponent<P & React.RefAttributes<T>>>}
+ */
+declare function withDefaultStyleSlot<P extends unknown, T>(Component: React.ComponentType<P> | React.ForwardRefExoticComponent<P & React.RefAttributes<T>>, slotKey: string): React.MemoExoticComponent<React.ForwardRefExoticComponent<P & React.RefAttributes<T>>>;
+import React from "react";
+//# sourceMappingURL=with-default-style-slot.d.ts.map

package/build/utils/with-default-style-slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-default-style-slot.d.ts","sourceRoot":"/src/","sources":["utils/with-default-style-slot.jsx"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sCAPsB,CAAC,kBACV,CAAC,aACH,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,yBAAyB,CAAC,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,WAEpF,MAAM,GACJ,KAAK,CAAC,mBAAmB,CAAC,KAAK,CAAC,yBAAyB,CAAC,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CA4BlG;kBAtD+B,OAAO"}

package/build/utils/with-default-style-slot.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
+import React, { forwardRef } from "react";
+import { WithDefaultStyle, useMergedStyle } from "./default-style";
+import memo from "set-state-compare/build/memo.js";
+/**
+ * Wires `Component` into the api-maker default-style context as a slot.
+ * Inherits accumulated defaults for `slotKey`, merges them with the caller's
+ * `style` prop, and re-provides the merged list so nested instances of the
+ * same component continue to inherit.
+ *
+ * Caller usage mirrors the built-in `Text` wrapper:
+ *
+ * ```jsx
+ * import {Link as ExpoLink} from "expo-router"
+ * import withDefaultStyleSlot from "@kaspernj/api-maker/build/utils/with-default-style-slot"
+ *
+ * const Link = withDefaultStyleSlot(ExpoLink, "Link")
+ *
+ * // …consumer tree wraps in <WithDefaultStyle style={{Link: {color: "red"}}}> …
+ * ```
+ *
+ * @template {object} P
+ * @template T
+ * @param {React.ComponentType<P> | React.ForwardRefExoticComponent<P & React.RefAttributes<T>>} Component
+ *   Underlying component to wrap.
+ * @param {string} slotKey Slot name to register defaults under.
+ * @returns {React.MemoExoticComponent<React.ForwardRefExoticComponent<P & React.RefAttributes<T>>>}
+ */
+const withDefaultStyleSlot = (Component, slotKey) => {
+    const RenderComponent = /** @type {React.ComponentType<Record<string, unknown>>} */ (
+    /** @type {unknown} */ (Component));
+    const Wrapped = forwardRef((/** @type {Record<string, unknown>} */ props, ref) => {
+        const { style, ...restProps } = props;
+        const { newDefaultStyle, stylesList } = useMergedStyle(style, slotKey);
+        return (_jsx(WithDefaultStyle, { style: newDefaultStyle, children: _jsx(RenderComponent, { ref: ref, style: stylesList, ...restProps }) }));
+    });
+    const displayName = `WithDefaultStyleSlot(${Component.displayName || Component.name || slotKey})`;
+    Wrapped.displayName = displayName;
+    const Memoized = /** @type {React.MemoExoticComponent<React.ForwardRefExoticComponent<P & React.RefAttributes<T>>>} */ (
+    /** @type {unknown} */ (memo(Wrapped)));
+    Memoized.displayName = displayName;
+    return Memoized;
+};
+export default withDefaultStyleSlot;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1kZWZhdWx0LXN0eWxlLXNsb3QuanMiLCJzb3VyY2VSb290IjoiL3NyYy8iLCJzb3VyY2VzIjpbInV0aWxzL3dpdGgtZGVmYXVsdC1zdHlsZS1zbG90LmpzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsWUFBWTtBQUNaLE9BQU8sS0FBSyxFQUFFLEVBQUMsVUFBVSxFQUFDLE1BQU0sT0FBTyxDQUFBO0FBQ3ZDLE9BQU8sRUFBQyxnQkFBZ0IsRUFBRSxjQUFjLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQTtBQUNoRSxPQUFPLElBQUksTUFBTSxpQ0FBaUMsQ0FBQTtBQUVsRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F1Qkc7QUFDSCxNQUFNLG9CQUFvQixHQUFHLENBQUMsU0FBUyxFQUFFLE9BQU8sRUFBRSxFQUFFO0lBQ2xELE1BQU0sZUFBZSxHQUFHLDJEQUEyRCxDQUFDO0lBQ2xGLHNCQUFzQixDQUFDLENBQUMsU0FBUyxDQUFDLENBQ25DLENBQUE7SUFDRCxNQUFNLE9BQU8sR0FBRyxVQUFVLENBQUMsQ0FBQyxzQ0FBc0MsQ0FBQyxLQUFLLEVBQUUsR0FBRyxFQUFFLEVBQUU7UUFDL0UsTUFBTSxFQUFDLEtBQUssRUFBRSxHQUFHLFNBQVMsRUFBQyxHQUFHLEtBQUssQ0FBQTtRQUNuQyxNQUFNLEVBQUMsZUFBZSxFQUFFLFVBQVUsRUFBQyxHQUFHLGNBQWMsQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUE7UUFFcEUsT0FBTyxDQUNMLEtBQUMsZ0JBQWdCLElBQUMsS0FBSyxFQUFFLGVBQWUsWUFDdEMsS0FBQyxlQUFlLElBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsVUFBVSxLQUFNLFNBQVMsR0FBSSxHQUM5QyxDQUNwQixDQUFBO0lBQ0gsQ0FBQyxDQUFDLENBQUE7SUFFRixNQUFNLFdBQVcsR0FBRyx3QkFBd0IsU0FBUyxDQUFDLFdBQVcsSUFBSSxTQUFTLENBQUMsSUFBSSxJQUFJLE9BQU8sR0FBRyxDQUFBO0lBRWpHLE9BQU8sQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFBO0lBRWpDLE1BQU0sUUFBUSxHQUFHLHFHQUFxRyxDQUFDO0lBQ3JILHNCQUFzQixDQUFDLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQ3ZDLENBQUE7SUFFRCxRQUFRLENBQUMsV0FBVyxHQUFHLFdBQVcsQ0FBQTtJQUVsQyxPQUFPLFFBQVEsQ0FBQTtBQUNqQixDQUFDLENBQUE7QUFFRCxlQUFlLG9CQUFvQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5pbXBvcnQgUmVhY3QsIHtmb3J3YXJkUmVmfSBmcm9tIFwicmVhY3RcIlxuaW1wb3J0IHtXaXRoRGVmYXVsdFN0eWxlLCB1c2VNZXJnZWRTdHlsZX0gZnJvbSBcIi4vZGVmYXVsdC1zdHlsZVwiXG5pbXBvcnQgbWVtbyBmcm9tIFwic2V0LXN0YXRlLWNvbXBhcmUvYnVpbGQvbWVtby5qc1wiXG5cbi8qKlxuICogV2lyZXMgYENvbXBvbmVudGAgaW50byB0aGUgYXBpLW1ha2VyIGRlZmF1bHQtc3R5bGUgY29udGV4dCBhcyBhIHNsb3QuXG4gKiBJbmhlcml0cyBhY2N1bXVsYXRlZCBkZWZhdWx0cyBmb3IgYHNsb3RLZXlgLCBtZXJnZXMgdGhlbSB3aXRoIHRoZSBjYWxsZXInc1xuICogYHN0eWxlYCBwcm9wLCBhbmQgcmUtcHJvdmlkZXMgdGhlIG1lcmdlZCBsaXN0IHNvIG5lc3RlZCBpbnN0YW5jZXMgb2YgdGhlXG4gKiBzYW1lIGNvbXBvbmVudCBjb250aW51ZSB0byBpbmhlcml0LlxuICpcbiAqIENhbGxlciB1c2FnZSBtaXJyb3JzIHRoZSBidWlsdC1pbiBgVGV4dGAgd3JhcHBlcjpcbiAqXG4gKiBgYGBqc3hcbiAqIGltcG9ydCB7TGluayBhcyBFeHBvTGlua30gZnJvbSBcImV4cG8tcm91dGVyXCJcbiAqIGltcG9ydCB3aXRoRGVmYXVsdFN0eWxlU2xvdCBmcm9tIFwiQGthc3Blcm5qL2FwaS1tYWtlci9idWlsZC91dGlscy93aXRoLWRlZmF1bHQtc3R5bGUtc2xvdFwiXG4gKlxuICogY29uc3QgTGluayA9IHdpdGhEZWZhdWx0U3R5bGVTbG90KEV4cG9MaW5rLCBcIkxpbmtcIilcbiAqXG4gKiAvLyDigKZjb25zdW1lciB0cmVlIHdyYXBzIGluIDxXaXRoRGVmYXVsdFN0eWxlIHN0eWxlPXt7TGluazoge2NvbG9yOiBcInJlZFwifX19PiDigKZcbiAqIGBgYFxuICpcbiAqIEB0ZW1wbGF0ZSB7b2JqZWN0fSBQXG4gKiBAdGVtcGxhdGUgVFxuICogQHBhcmFtIHtSZWFjdC5Db21wb25lbnRUeXBlPFA+IHwgUmVhY3QuRm9yd2FyZFJlZkV4b3RpY0NvbXBvbmVudDxQICYgUmVhY3QuUmVmQXR0cmlidXRlczxUPj59IENvbXBvbmVudFxuICogICBVbmRlcmx5aW5nIGNvbXBvbmVudCB0byB3cmFwLlxuICogQHBhcmFtIHtzdHJpbmd9IHNsb3RLZXkgU2xvdCBuYW1lIHRvIHJlZ2lzdGVyIGRlZmF1bHRzIHVuZGVyLlxuICogQHJldHVybnMge1JlYWN0Lk1lbW9FeG90aWNDb21wb25lbnQ8UmVhY3QuRm9yd2FyZFJlZkV4b3RpY0NvbXBvbmVudDxQICYgUmVhY3QuUmVmQXR0cmlidXRlczxUPj4+fVxuICovXG5jb25zdCB3aXRoRGVmYXVsdFN0eWxlU2xvdCA9IChDb21wb25lbnQsIHNsb3RLZXkpID0+IHtcbiAgY29uc3QgUmVuZGVyQ29tcG9uZW50ID0gLyoqIEB0eXBlIHtSZWFjdC5Db21wb25lbnRUeXBlPFJlY29yZDxzdHJpbmcsIHVua25vd24+Pn0gKi8gKFxuICAgIC8qKiBAdHlwZSB7dW5rbm93bn0gKi8gKENvbXBvbmVudClcbiAgKVxuICBjb25zdCBXcmFwcGVkID0gZm9yd2FyZFJlZigoLyoqIEB0eXBlIHtSZWNvcmQ8c3RyaW5nLCB1bmtub3duPn0gKi8gcHJvcHMsIHJlZikgPT4ge1xuICAgIGNvbnN0IHtzdHlsZSwgLi4ucmVzdFByb3BzfSA9IHByb3BzXG4gICAgY29uc3Qge25ld0RlZmF1bHRTdHlsZSwgc3R5bGVzTGlzdH0gPSB1c2VNZXJnZWRTdHlsZShzdHlsZSwgc2xvdEtleSlcblxuICAgIHJldHVybiAoXG4gICAgICA8V2l0aERlZmF1bHRTdHlsZSBzdHlsZT17bmV3RGVmYXVsdFN0eWxlfT5cbiAgICAgICAgPFJlbmRlckNvbXBvbmVudCByZWY9e3JlZn0gc3R5bGU9e3N0eWxlc0xpc3R9IHsuLi5yZXN0UHJvcHN9IC8+XG4gICAgICA8L1dpdGhEZWZhdWx0U3R5bGU+XG4gICAgKVxuICB9KVxuXG4gIGNvbnN0IGRpc3BsYXlOYW1lID0gYFdpdGhEZWZhdWx0U3R5bGVTbG90KCR7Q29tcG9uZW50LmRpc3BsYXlOYW1lIHx8IENvbXBvbmVudC5uYW1lIHx8IHNsb3RLZXl9KWBcblxuICBXcmFwcGVkLmRpc3BsYXlOYW1lID0gZGlzcGxheU5hbWVcblxuICBjb25zdCBNZW1vaXplZCA9IC8qKiBAdHlwZSB7UmVhY3QuTWVtb0V4b3RpY0NvbXBvbmVudDxSZWFjdC5Gb3J3YXJkUmVmRXhvdGljQ29tcG9uZW50PFAgJiBSZWFjdC5SZWZBdHRyaWJ1dGVzPFQ+Pj59ICovIChcbiAgICAvKiogQHR5cGUge3Vua25vd259ICovIChtZW1vKFdyYXBwZWQpKVxuICApXG5cbiAgTWVtb2l6ZWQuZGlzcGxheU5hbWUgPSBkaXNwbGF5TmFtZVxuXG4gIHJldHVybiBNZW1vaXplZFxufVxuXG5leHBvcnQgZGVmYXVsdCB3aXRoRGVmYXVsdFN0eWxlU2xvdFxuIl19

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kaspernj/api-maker",
   "type": "module",
-  "version": "1.0.2166",
+  "version": "1.0.2168",
   "description": "My new module",
   "files": [
     "build/**"