@kaspernj/api-maker 1.0.2159 → 1.0.2161

package/build/devise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"devise.d.ts","sourceRoot":"/src/","sources":["devise.js"],"names":[],"mappings":"AA0BA,sBAAsB;AACtB;IACE,wBAAwB;IACxB,yCAEC;IAED,gCAAgC;IAChC,kBADc,cAAc,CAO3B;IAED,cAAc;IACd,4EAEC;IAED,oBAAoB;IACpB,iDAaC;IAED,gBAAgB;IAChB,iCAKC;IAED,0BAA0B;IAC1B,2BADc,MAAM,EAAE,CAGrB;IAED;;;OA8BC;IAED;;;;;OAKG;IACH,6BAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,GAAG,CAAC,CAgBxB;IAED,qBAAqB;IACrB,kDAMC;IASD,oBAAoB;IACpB,qCAEC;IAED,wCAqBC;IAED;;;;;;OAMG;IACH,kDAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAaxC;IAED;;;OAGG;IACH,uDAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CASxC;IAED;;;;;OAKG;IACH,qCAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,GAAG,CAAC,CAIxB;IAED;;;;;OAKG;IACH,+CAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,IAAI,CAAC,CAIzB;IAtFD,uBAAuB;IACvB,qCAIC;IAqFC,aAAkB;IAGpB,uBAAuB;IACvB,iCAMC;IAED,6BAA6B;IAC7B,2CAMC;IAED,wBAAwB;IACxB,kCAkBC;CACF"}
+{"version":3,"file":"devise.d.ts","sourceRoot":"/src/","sources":["devise.js"],"names":[],"mappings":"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"}

package/build/devise.js

@@ -1,3 +1,4 @@
+// @ts-check
 import * as inflection from "inflection"; // eslint-disable-line sort-imports
 import CableConnectionPool from "./cable-connection-pool.js";
 import { createContext } from "react";
@@ -6,23 +7,44 @@ import events from "./events.js";
 import modelClassRequire from "./model-class-require.js";
 import SessionStatusUpdater from "./session-status-updater.js"; // eslint-disable-line sort-imports
 import Services from "./services.js"; // eslint-disable-line sort-imports
+/** @typedef {{scopes?: Record<string, boolean>, currentApiMakerDevise?: ApiMakerDevise}} ApiMakerDeviseShared */
+/** @typedef {{signed_in: boolean}} DeviseSessionStatusScope */
+/**
+ * @typedef {object} DeviseSessionStatusResult
+ * @property {string} [csrf_token]
+ * @property {Record<string, DeviseSessionStatusScope>} scopes
+ * @property {string} [shadow_session_token]
+ * @property {DeviseSessionStatusResult} [session_status]
+ */
+/** @typedef {{rememberMe?: boolean, scope?: string, signedIn?: boolean, skipSignInEvent?: boolean}} DeviseScopeArgs */
+/** @typedef {DeviseSessionStatusResult & {model?: import("./base-model.js").default | import("./base-model.js").default[]}} DeviseSignInResponse */
+/** @typedef {{httpResponse: DeviseSessionStatusResult, scope: string, websocketArgs: DeviseScopeArgs}} SyncSessionArgs */
+/** @typedef {import("./base-model.js").default | null} DeviseCurrentScope */
 if (!globalThis.ApiMakerDevise)
     globalThis.ApiMakerDevise = { scopes: {} };
-const shared = globalThis.ApiMakerDevise;
+const shared = /** @type {ApiMakerDeviseShared} */ (globalThis.ApiMakerDevise);
 /** DeviseScope. */
 class DeviseScope {
-    /** Constructor. */
+    /**
+     * Constructor.
+     * @param {string} scope
+     * @param {DeviseScopeArgs} args
+     */
     constructor(scope, args) {
         this.args = args;
         this.context = createContext(undefined);
         this.scope = scope;
     }
-    /** getContext. */
+    /** @returns {import("react").Context<DeviseCurrentScope | undefined>} */
     getContext = () => this.context;
 }
 /** ApiMakerDevise. */
 export default class ApiMakerDevise {
-    /** callSignOutEvent. */
+    /**
+     * Emits the shared sign-out event payload for one scope.
+     * @param {DeviseScopeArgs} args
+     * @returns {void}
+     */
     static callSignOutEvent(args) {
         events.emit("onDeviseSignOut", { args });
     }
@@ -33,11 +55,18 @@ export default class ApiMakerDevise {
         }
         return shared.currentApiMakerDevise;
     }
-    /** events. */
+    /**
+     * Returns the shared event emitter used for Devise lifecycle events.
+     * @returns {typeof events}
+     */
     static events() {
         return events;
     }
-    /** addUserScope. */
+    /**
+     * Registers one Devise scope and its helper accessors.
+     * @param {string} scope
+     * @param {DeviseScopeArgs} args
+     */
     static addUserScope(scope, args = {}) {
         const scopeCamelized = inflection.camelize(scope);
         const currentMethodName = `current${scopeCamelized}`;
@@ -51,7 +80,11 @@ export default class ApiMakerDevise {
         ApiMakerDevise[getArgsMethodName] = () => args;
         ApiMakerDevise[getScopeName] = () => scopeInstance;
     }
-    /** getScope. */
+    /**
+     * Returns the registered scope helper for one scope name.
+     * @param {string} scope
+     * @returns {DeviseScope}
+     */
     static getScope(scope) {
         const scopeCamelized = inflection.camelize(scope);
         const getScopeName = `get${scopeCamelized}Scope`;
@@ -61,13 +94,20 @@ export default class ApiMakerDevise {
     static registeredScopes() {
         return Object.keys(shared.scopes);
     }
+    /**
+     * Signs in one scope over HTTP and refreshes websocket auth state.
+     * @param {string} username
+     * @param {string} password
+     * @param {DeviseScopeArgs} args
+     * @returns {Promise<{model: import("./base-model.js").default | undefined, response: DeviseSignInResponse}>}
+     */
     static async signIn(username, password, args = {}) {
         if (!args.scope)
             args.scope = "user";
         const postData = { username, password, args };
         // Sign in over HTTP first so Devise can write the real session cookie and
         // remember-me token in the HTTP response.
-        const response = await Services.current().sendRequest("Devise::SignIn", postData, { forceHttp: true });
+        const response = /** @type {DeviseSignInResponse} */ (await Services.current().sendRequest("Devise::SignIn", postData, { forceHttp: true }));
         let model = response.model;
         if (Array.isArray(model))
             model = model[0];
@@ -89,13 +129,13 @@ export default class ApiMakerDevise {
     /**
      * Synchronizes the current backend auth state into real HTTP response cookies.
      *
-     * @param {Record<string, any>} [args]
-     * @returns {Promise<any>}
+     * @param {DeviseScopeArgs} [args]
+     * @returns {Promise<DeviseSessionStatusResult>}
      */
     static async persistSession(args = {}) {
         if (!args.scope)
             args.scope = "user";
-        const response = await Services.current().sendRequest("Devise::PersistSession", args, { forceHttp: true });
+        const response = /** @type {DeviseSessionStatusResult} */ (await Services.current().sendRequest("Devise::PersistSession", args, { forceHttp: true }));
         const sessionStatusUpdater = SessionStatusUpdater.current();
         if (response.session_status) {
             sessionStatusUpdater.applyResult(response.session_status);
@@ -105,27 +145,43 @@ export default class ApiMakerDevise {
         }
         return response;
     }
-    /** updateSession. */
+    /**
+     * Updates the locally cached current model for one scope.
+     * @param {DeviseCurrentScope} model
+     * @param {DeviseScopeArgs} args
+     */
     static updateSession(model, args = {}) {
         if (!args.scope)
             args.scope = "user";
         const camelizedScopeName = inflection.camelize(args.scope, true);
         ApiMakerDevise.current().currents[camelizedScopeName] = model;
     }
-    /** hasCurrentScope. */
+    /**
+     * Returns whether the current scope cache has been initialized locally.
+     * @param {string} scope
+     * @returns {boolean}
+     */
     hasCurrentScope(scope) {
         const camelizedScopeName = inflection.camelize(scope, true);
         return camelizedScopeName in ApiMakerDevise.current().currents;
     }
-    /** setSignedOut. */
+    /**
+     * Marks one scope as signed out in the local current-model cache.
+     * @param {DeviseScopeArgs} args
+     */
     static setSignedOut(args) {
         ApiMakerDevise.current().currents[inflection.camelize(args.scope, true)] = null;
     }
+    /**
+     * Signs out one scope over HTTP and refreshes websocket auth state.
+     * @param {DeviseScopeArgs} args
+     * @returns {Promise<DeviseSessionStatusResult>}
+     */
     static async signOut(args = {}) {
         if (!args.scope) {
             args.scope = "user";
         }
-        const response = await Services.current().sendRequest("Devise::SignOut", { args }, { forceHttp: true });
+        const response = /** @type {DeviseSessionStatusResult} */ (await Services.current().sendRequest("Devise::SignOut", { args }, { forceHttp: true }));
         const sessionStatus = await ApiMakerDevise.syncSessionStatusAndRefreshWebsocket({
             httpResponse: response,
             scope: args.scope,
@@ -144,8 +200,8 @@ export default class ApiMakerDevise {
      * Applies the latest HTTP session status locally, then refreshes the
      * existing websocket connection so ApiMaker commands use the same auth.
      *
-     * @param {Record<string, any>} args
-     * @returns {Promise<Record<string, any>>}
+     * @param {SyncSessionArgs} args
+     * @returns {Promise<DeviseSessionStatusResult>}
      */
     static async syncSessionStatusAndRefreshWebsocket(args) {
         const sessionStatus = await ApiMakerDevise.syncSessionStatusFromHttpResponse(args.httpResponse);
@@ -158,8 +214,9 @@ export default class ApiMakerDevise {
         return sessionStatus;
     }
     /**
-     * @param {Record<string, any>} httpResponse
-     * @returns {Promise<Record<string, any>>}
+     * Updates local session status from one HTTP response payload.
+     * @param {DeviseSessionStatusResult} httpResponse
+     * @returns {Promise<DeviseSessionStatusResult>}
      */
     static async syncSessionStatusFromHttpResponse(httpResponse) {
         const sessionStatusUpdater = SessionStatusUpdater.current();
@@ -170,16 +227,16 @@ export default class ApiMakerDevise {
     /**
      * Refreshes ApiMaker auth inside the existing websocket connection.
      *
-     * @param {Record<string, any>} args
-     * @returns {Promise<any>}
+     * @param {DeviseScopeArgs & {shadowSessionToken?: string}} args
+     * @returns {Promise<DeviseSessionStatusResult>}
      */
     static async refreshWebsocketSession(args) {
-        return Services.current().sendRequest("Devise::PersistSession", args);
+        return /** @type {DeviseSessionStatusResult} */ (await Services.current().sendRequest("Devise::PersistSession", args));
     }
     /**
      * Refreshes auth on the existing subscriptions channel pools.
      *
-     * @param {Record<string, any>} args
+     * @param {DeviseScopeArgs & {shadowSessionToken?: string}} args
      * @returns {Promise<void>}
      */
     static async refreshSubscriptionAuthentication(args) {
@@ -187,23 +244,35 @@ export default class ApiMakerDevise {
     }
     /** Constructor. */
     constructor() {
-        this.currents = {};
+        this.currents = /** @type {Record<string, DeviseCurrentScope>} */ ({});
     }
-    /** getCurrentScope. */
+    /**
+     * Returns the current model cached for one scope.
+     * @param {string} scope
+     * @returns {DeviseCurrentScope}
+     */
     getCurrentScope(scope) {
         if (!(scope in this.currents)) {
             this.currents[scope] = this.loadCurrentScope(scope);
         }
         return this.currents[scope];
     }
-    /** hasGlobalCurrentScope. */
+    /**
+     * Returns whether the server rendered current-scope payload for one scope.
+     * @param {string} scope
+     * @returns {boolean}
+     */
     hasGlobalCurrentScope(scope) {
         if (globalThis.apiMakerDeviseCurrent && scope in globalThis.apiMakerDeviseCurrent) {
             return true;
         }
         return false;
     }
-    /** loadCurrentScope. */
+    /**
+     * Hydrates the current scope model from the server rendered payload.
+     * @param {string} scope
+     * @returns {DeviseCurrentScope}
+     */
     loadCurrentScope(scope) {
         if (!this.hasGlobalCurrentScope(scope)) {
             return null;
@@ -220,4 +289,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":["import * 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\nif (!globalThis.ApiMakerDevise) globalThis.ApiMakerDevise = {scopes: {}}\n\nconst shared = globalThis.ApiMakerDevise\n\n/** DeviseScope. */\nclass DeviseScope {\n  /** Constructor. */\n  constructor(scope, args) {\n    this.args = args\n    this.context = createContext(undefined)\n    this.scope = scope\n  }\n\n  /** getContext. */\n  getContext = () => this.context\n}\n\n/** ApiMakerDevise. */\nexport default class ApiMakerDevise {\n  /** callSignOutEvent. */\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  /** events. */\n  static events() {\n    return events\n  }\n\n  /** addUserScope. */\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  /** getScope. */\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  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 = await Services.current().sendRequest(\"Devise::SignIn\", postData, {forceHttp: true})\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 {Record<string, any>} [args]\n   * @returns {Promise<any>}\n   */\n  static async persistSession(args = {}) {\n    if (!args.scope) args.scope = \"user\"\n\n    const response = await Services.current().sendRequest(\"Devise::PersistSession\", args, {forceHttp: true})\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  /** updateSession. */\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  /** hasCurrentScope. */\n  hasCurrentScope(scope) {\n    const camelizedScopeName = inflection.camelize(scope, true)\n\n    return camelizedScopeName in ApiMakerDevise.current().currents\n  }\n\n  /** setSignedOut. */\n  static setSignedOut(args) {\n    ApiMakerDevise.current().currents[inflection.camelize(args.scope, true)] = null\n  }\n\n  static async signOut(args = {}) {\n    if (!args.scope) {\n      args.scope = \"user\"\n    }\n\n    const response = await Services.current().sendRequest(\"Devise::SignOut\", {args}, {forceHttp: true})\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 {Record<string, any>} args\n   * @returns {Promise<Record<string, any>>}\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   * @param {Record<string, any>} httpResponse\n   * @returns {Promise<Record<string, any>>}\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 {Record<string, any>} args\n   * @returns {Promise<any>}\n   */\n  static async refreshWebsocketSession(args) {\n    return Services.current().sendRequest(\"Devise::PersistSession\", args)\n  }\n\n  /**\n   * Refreshes auth on the existing subscriptions channel pools.\n   *\n   * @param {Record<string, any>} 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 = {}\n  }\n\n  /** getCurrentScope. */\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  /** hasGlobalCurrentScope. */\n  hasGlobalCurrentScope(scope) {\n    if (globalThis.apiMakerDeviseCurrent && scope in globalThis.apiMakerDeviseCurrent) {\n      return true\n    }\n\n    return false\n  }\n\n  /** loadCurrentScope. */\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  /** @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"]}

package/build/draggable-sort/controller.d.ts

@@ -1,53 +1,144 @@
+/** @typedef {import("eventemitter3").EventEmitter} DraggableSortEventEmitter */
+/** @typedef {import("react-native").LayoutRectangle} DraggableSortLayout */
+/** @typedef {import("react-native").PanResponderGestureState} DraggableSortGestureState */
+/** @typedef {{x: number, y: number}} DraggableSortPosition */
+/** @typedef {(item: object) => string} DraggableSortKeyExtractor */
+/**
+ * @typedef {object} DraggableSortItemData
+ * @property {number} index
+ * @property {object} item
+ * @property {number} position
+ * @property {number} [baseX]
+ * @property {DraggableSortEventEmitter} [events]
+ * @property {DraggableSortLayout} [initialLayout]
+ * @property {string} [key]
+ * @property {DraggableSortLayout} [layout]
+ */
+/**
+ * @typedef {object} DraggableSortDragEndArgs
+ * @property {number} fromIndex
+ * @property {object} fromItem
+ * @property {number} fromPosition
+ * @property {object} item
+ * @property {DraggableSortItemData} itemData
+ * @property {object|null} toItem
+ * @property {number|null} toPosition
+ */
 /** Controller for drag-sort row state and events. */
 export default class DraggableSortController {
-    /** Constructor. */
+    /**
+     * Set up drag-sort state for a list of draggable items.
+     * @param {object} root0
+     * @param {object[]} root0.data
+     * @param {DraggableSortEventEmitter} [root0.events]
+     * @param {DraggableSortKeyExtractor} root0.keyExtractor
+     */
     constructor({ data, events, keyExtractor }: {
-        data: any;
-        events: any;
-        keyExtractor: any;
+        data: object[];
+        events?: DraggableSortEventEmitter;
+        keyExtractor: DraggableSortKeyExtractor;
     });
-    data: any;
+    data: any[];
     currentOrder: any[];
-    events: any;
-    keyExtractor: any;
+    events: EventEmitter<string | symbol, any>;
+    keyExtractor: DraggableSortKeyExtractor;
     draggedItem: any;
-    draggedItemData: any;
+    draggedItemData: DraggableSortItemData;
     draggedItemNewPosition: number;
     draggedOverItem: any;
-    draggedOverItemData: any;
-    itemData: {};
-    /** getEvents. */
-    getEvents: () => any;
-    /** getItemDataForItem. */
-    getItemDataForItem: (item: any) => any;
-    /** getItemDataForKey. */
-    getItemDataForKey: (key: any) => any;
-    /** getItemDataForIndex. */
-    getItemDataForIndex: (index: any) => any;
-    /** onDragStart. */
+    draggedOverItemData: DraggableSortItemData;
+    itemData: Record<number, DraggableSortItemData>;
+    /** @returns {DraggableSortEventEmitter} */
+    getEvents: () => DraggableSortEventEmitter;
+    /**
+     * Return the tracked drag metadata for the given item instance.
+     * @param {object} item
+     * @returns {DraggableSortItemData|undefined}
+     */
+    getItemDataForItem: (item: object) => DraggableSortItemData | undefined;
+    /**
+     * Look up item metadata by its extracted stable key.
+     * @param {string} key
+     * @returns {DraggableSortItemData|undefined}
+     */
+    getItemDataForKey: (key: string) => DraggableSortItemData | undefined;
+    /**
+     * Return the tracked drag metadata stored for a list index.
+     * @param {number} index
+     * @returns {DraggableSortItemData|undefined}
+     */
+    getItemDataForIndex: (index: number) => DraggableSortItemData | undefined;
+    /**
+     * Mark an item as the active dragged row and publish the drag-start event.
+     * @param {object} root0
+     * @param {object} root0.item
+     * @param {number} root0.itemIndex
+     */
     onDragStart: ({ item, itemIndex }: {
-        item: any;
-        itemIndex: any;
+        item: object;
+        itemIndex: number;
     }) => void;
-    draggedItemIndex: any;
-    draggedItemPosition: any;
-    /** onDragEnd. */
+    draggedItemIndex: number;
+    draggedItemPosition: number;
+    /** Finish the current drag and notify listeners about the final ordering. */
     onDragEnd: () => void;
-    /** onItemLayout. */
+    /**
+     * Store layout data and event bindings for a rendered draggable item.
+     * @param {object} root0
+     * @param {DraggableSortEventEmitter} root0.events
+     * @param {number} root0.index
+     * @param {object} root0.item
+     * @param {DraggableSortLayout} root0.layout
+     */
     onItemLayout: ({ events, index, item, layout }: {
-        events: any;
-        index: any;
-        item: any;
-        layout: any;
+        events: DraggableSortEventEmitter;
+        index: number;
+        item: object;
+        layout: DraggableSortLayout;
     }) => void;
-    /** onMove. */
+    /**
+     * Update ordering as the active dragged item crosses other item positions.
+     * @param {object} root0
+     * @param {DraggableSortGestureState} root0.gestate
+     */
     onMove: ({ gestate }: {
-        gestate: any;
+        gestate: DraggableSortGestureState;
     }) => void;
-    /** setInitialDragPosition. */
-    setInitialDragPosition: (initialDragPosition: any) => void;
-    initialDragPosition: any;
-    /** updatePositionOfItems. */
+    /**
+     * Store the touch position where the current drag gesture started.
+     * @param {DraggableSortPosition} initialDragPosition
+     */
+    setInitialDragPosition: (initialDragPosition: DraggableSortPosition) => void;
+    initialDragPosition: DraggableSortPosition;
+    /** Animate non-dragged items into their current ordered positions. */
     updatePositionOfItems(): void;
 }
+export type DraggableSortEventEmitter = import("eventemitter3").EventEmitter;
+export type DraggableSortLayout = import("react-native").LayoutRectangle;
+export type DraggableSortGestureState = import("react-native").PanResponderGestureState;
+export type DraggableSortPosition = {
+    x: number;
+    y: number;
+};
+export type DraggableSortKeyExtractor = (item: object) => string;
+export type DraggableSortItemData = {
+    index: number;
+    item: object;
+    position: number;
+    baseX?: number;
+    events?: DraggableSortEventEmitter;
+    initialLayout?: DraggableSortLayout;
+    key?: string;
+    layout?: DraggableSortLayout;
+};
+export type DraggableSortDragEndArgs = {
+    fromIndex: number;
+    fromItem: object;
+    fromPosition: number;
+    item: object;
+    itemData: DraggableSortItemData;
+    toItem: object | null;
+    toPosition: number | null;
+};
+import { EventEmitter } from "eventemitter3";
 //# sourceMappingURL=controller.d.ts.map

package/build/draggable-sort/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"/src/","sources":["draggable-sort/controller.js"],"names":[],"mappings":"AAGA,qDAAqD;AACrD;IACE,mBAAmB;IACnB;;;;OAsBC;IArBC,UAAgB;IAChB,oBAA6B;IAC7B,YAA0C;IAC1C,kBAAgC;IAEhC,iBAAuB;IACvB,qBAA2B;IAC3B,+BAAkC;IAElC,qBAA2B;IAC3B,yBAA+B;IAE/B,aAAkB;IAWpB,iBAAiB;IACjB,qBAA6B;IAE7B,0BAA0B;IAC1B,qBAAsB,SAAI,SAAsD;IAEhF,yBAAyB;IACzB,oBAAqB,QAAG,SAAqE;IAE7F,2BAA2B;IAC3B,sBAAuB,UAAK,SAAkC;IAE9D,mBAAmB;IACnB,cAAe;;;KAAiB,UAQ/B;IAJG,sBAAiC;IACjC,yBAAwD;IAK5D,iBAAiB;IACjB,sBAuBC;IAED,oBAAoB;IACpB,eAAgB;;;;;KAA6B,UAa5C;IAED,cAAc;IACd,SAAU;;KAAS,UA8BlB;IAED,8BAA8B;IAC9B,yBAA0B,wBAAmB,UAE5C;IADC,yBAA8C;IAGhD,6BAA6B;IAC7B,8BAiBC;CACF"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"/src/","sources":["draggable-sort/controller.js"],"names":[],"mappings":"AAIA,gFAAgF;AAChF,4EAA4E;AAC5E,2FAA2F;AAC3F,8DAA8D;AAC9D,oEAAoE;AACpE;;;;;;;;;;GAUG;AACH;;;;;;;;;GASG;AAEH,qDAAqD;AACrD;IACE;;;;;;OAMG;IACH,4CAJG;QAAwB,IAAI,EAApB,MAAM,EAAE;QAC0B,MAAM,GAAxC,yBAAyB;QACQ,YAAY,EAA7C,yBAAyB;KACnC,EAoBA;IAlBC,YAA0C;IAC1C,oBAAuD;IACvD,2CAAqF;IACrF,wCAA2E;IAC3E,iBAAoD;IACpD,uCAAuE;IACvE,+BAA+D;IAC/D,qBAAwD;IACxD,2CAA2E;IAC3E,gDAAyE;IAW3E,2CAA2C;IAC3C,iBADc,yBAAyB,CACV;IAE7B;;;;OAIG;IACH,qBAAsB,MAHX,MAGe,KAFb,qBAAqB,GAAC,SAAS,CAEoC;IAEhF;;;;OAIG;IACH,oBAAqB,KAHV,MAGa,KAFX,qBAAqB,GAAC,SAAS,CAEgE;IAE5G;;;;OAIG;IACH,sBAAuB,OAHZ,MAGiB,KAFf,qBAAqB,GAAC,SAAS,CAEkB;IAE9D;;;;;OAKG;IACH,cAAe,qBAHZ;QAAsB,IAAI,EAAlB,MAAM;QACQ,SAAS,EAAvB,MAAM;KAEe,UAU/B;IAJG,yBAAiC;IACjC,4BAAwD;IAK5D,6EAA6E;IAC7E,sBA2BC;IAED;;;;;;;OAOG;IACH,eAAgB,iCALb;QAAyC,MAAM,EAAvC,yBAAyB;QACX,KAAK,EAAnB,MAAM;QACQ,IAAI,EAAlB,MAAM;QACqB,MAAM,EAAjC,mBAAmB;KAEe,UAa5C;IAED;;;;OAIG;IACH,SAAU,aAFP;QAAyC,OAAO,EAAxC,yBAAyB;KAEjB,UA+BlB;IAED;;;OAGG;IACH,yBAA0B,qBAFf,qBAEkC,UAE5C;IADC,2CAA8C;IAGhD,sEAAsE;IACtE,8BAmBC;CACF;wCA3Na,OAAO,eAAe,EAAE,YAAY;kCACpC,OAAO,cAAc,EAAE,eAAe;wCACtC,OAAO,cAAc,EAAE,wBAAwB;oCAC/C;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC;wCACtB,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;WAGxB,MAAM;UACN,MAAM;cACN,MAAM;YACN,MAAM;aACN,yBAAyB;oBACzB,mBAAmB;UACnB,MAAM;aACN,mBAAmB;;;eAInB,MAAM;cACN,MAAM;kBACN,MAAM;UACN,MAAM;cACN,qBAAqB;YACrB,MAAM,GAAC,IAAI;gBACX,MAAM,GAAC,IAAI;;6BA1BE,eAAe"}