@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/table/table-settings.d.ts

@@ -1,53 +1,246 @@
 /** Persistent table settings manager. */
 export default class ApiMakerTableSettings {
-    /** Constructor. */
+    /**
+     * Constructor.
+     * @param {object} root0
+     * @param {TableSettingsTableLike} root0.table
+     */
     constructor({ table }: {
-        table: any;
+        table: TableSettingsTableLike;
     });
-    table: any;
+    table: TableSettingsTableLike;
     /** setTableSettingsLock. */
     setTableSettingsLock(): void;
     tableSettingsLock: any;
-    /** columns. */
-    columns: () => any;
-    /** columnsWithPositions. */
-    columnsWithPositions: () => any;
-    /** currentUser. */
-    currentUser: () => any;
-    /** identifier. */
-    identifier: () => any;
-    /** preparedColumns. */
-    preparedColumns: (tableSetting: any) => {
-        columns: any[];
-        preload: any[];
+    /** @returns {TableColumnDefinition[]} */
+    columns: () => TableColumnDefinition[];
+    /** @returns {Array<{column: TableColumnDefinition, identifier: string, position: number}>} */
+    columnsWithPositions: () => Array<{
+        column: TableColumnDefinition;
+        identifier: string;
+        position: number;
+    }>;
+    /** @returns {CurrentUserModel | null} */
+    currentUser: () => CurrentUserModel | null;
+    /** @returns {string} */
+    identifier: () => string;
+    /**
+     * preparedColumns.
+     * @param {TableSettingRecord} tableSetting
+     * @returns {PreparedColumnsResult | undefined}
+     */
+    preparedColumns: (tableSetting: TableSettingRecord) => PreparedColumnsResult | undefined;
+    /**
+     * orderedTableSettingColumns.
+     * @param {TableSettingRecord} tableSetting
+     * @returns {TableSettingColumnRecord[]}
+     */
+    orderedTableSettingColumns: (tableSetting: TableSettingRecord) => TableSettingColumnRecord[];
+    /** @returns {Promise<TableSettingRecord>} */
+    loadExistingOrCreateTableSettings: () => Promise<TableSettingRecord>;
+    /** @returns {Promise<TableSettingRecord | undefined>} */
+    loadTableSetting: () => Promise<TableSettingRecord | undefined>;
+    /**
+     * currentUserIdOrFallback.
+     * @returns {number | string}
+     */
+    currentUserIdOrFallback(): number | string;
+    /**
+     * currentUserTypeOrFallback.
+     * @returns {string | null}
+     */
+    currentUserTypeOrFallback(): string | null;
+    /**
+     * anonymouseUserId.
+     * @returns {string}
+     */
+    anonymouseUserId(): string;
+    /** @returns {Promise<TableSettingRecord>} */
+    createInitialTableSetting: () => Promise<TableSettingRecord>;
+    /**
+     * columnSaveData.
+     * @param {TableColumnDefinition} column
+     * @param {object} root0
+     * @param {string} root0.identifier
+     * @param {number} root0.position
+     * @returns {TableColumnSaveData}
+     */
+    columnSaveData(column: TableColumnDefinition, { identifier, position }: {
+        identifier: string;
+        position: number;
+    }): TableColumnSaveData;
+    /**
+     * updateTableSetting.
+     * @param {TableSettingRecord} tableSetting
+     * @returns {Promise<TableSettingRecord>}
+     */
+    updateTableSetting: (tableSetting: TableSettingRecord) => Promise<TableSettingRecord>;
+}
+export type CurrentUserModel = {
+    abilities: import("../base-model.js").ModelAbilityMap;
+    changes: import("../base-model.js").ModelDataMap;
+    collection: import("../collection.js").default<any>;
+    _identifierKey: string | number;
+    _markedForDestruction: boolean;
+    modelData: import("../base-model.js").ModelDataMap;
+    newRecord: boolean;
+    previousModelData: any;
+    preloadedRelationships: import("../base-model.js").PreloadedRelationshipMap;
+    relationshipsCache: import("../base-model.js").LoadedRelationshipMap;
+    relationships: import("../base-model.js").LoadedRelationshipMap;
+    uniqueKeyValue: number;
+    assignAttributes(newAttributes: ModelDataMap): void;
+    attributes(): ModelDataMap;
+    can(givenAbilityName: string): boolean;
+    clone(): /*elided*/ any;
+    cacheKey(): number | string;
+    localCacheKey(): string;
+    fullCacheKey(): string;
+    create(attributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    createRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    destroy(): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    ensureAbilities(listOfAbilities: string[]): Promise<void>;
+    getAttributes(): ModelDataMap;
+    handleResponseError(response: ModelCommandResponse): never;
+    identifierKey(): number | string;
+    isAssociationLoaded(associationName: string): boolean;
+    isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+    isAssociationPresent(associationName: string): boolean;
+    ensureAssociationLoaded(associationName: string): Promise<LoadedRelationshipValue>;
+    ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<LoadedRelationshipValue>;
+    isAttributeChanged(attributeName: string): boolean;
+    isChanged(): boolean;
+    isNewRecord(): boolean;
+    isPersisted(): boolean;
+    savedChangeToAttribute(attributeName: string): boolean;
+    setNewModel(model: /*elided*/ any): void;
+    setNewModelData(model: /*elided*/ any): void;
+    _isDateChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isIntegerChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    _isStringChanged(oldValue: ModelValue | null | undefined, newValue: ModelValue | null | undefined): boolean | void;
+    modelClassData(): ModelClassDataType;
+    reload(): Promise<void>;
+    save(): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    saveRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        model: /*elided*/ any;
+        response: ModelCommandResponse;
+    }>;
+    update(newAttributes?: ModelDataMap, options?: ParseValidationErrorsOptions): Promise<{
+        model: /*elided*/ any;
+        response?: object;
+    }>;
+    _refreshModelFromResponse(response: ModelCommandResponse): void;
+    _refreshModelDataFromResponse(response: ModelCommandResponse): void;
+    updateRaw(rawData: RawDataInput, options?: ParseValidationErrorsOptions & {
+        simpleModelErrors?: boolean;
+    }): Promise<{
+        response: ModelCommandResponse;
+        model: /*elided*/ any;
+    }>;
+    isValid(): never;
+    isValidOnServer(): Promise<{
+        valid: boolean;
+        errors: ValidationResponseErrors;
+    }>;
+    modelClass(): BaseModelClassType;
+    preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+    markForDestruction(): void;
+    markedForDestruction(): boolean;
+    uniqueKey(): number;
+    _callMemberCommand(args: ModelCommandDescriptor, commandArgs: ModelCommandOptions): import("../command-execution.js").default;
+    readAttribute(attributeName: string): ModelValue | null | undefined;
+    readAttributeUnderscore(attributeName: string): ModelValue | null | undefined;
+    isAttributeLoaded(attributeName: string): boolean;
+    _isPresent(value: ModelValue | null | undefined): boolean;
+    _loadBelongsToReflection(args: RelationshipLoadArgs, queryArgs?: import("../collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readBelongsToReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _loadHasManyReflection(args: RelationshipLoadArgs, queryArgs?: import("../collection.js").QueryArgsType): Promise</*elided*/ any[]>;
+    _loadHasOneReflection(args: RelationshipLoadArgs, queryArgs?: import("../collection.js").QueryArgsType): Promise</*elided*/ any | null>;
+    _readHasOneReflection({ reflectionName }: RelationshipLoadArgs): /*elided*/ any | null;
+    _readModelDataFromArgs(args?: BaseModelArgsObject): void;
+    _readPreloadedRelationships(preloaded: {
+        getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+    }): void;
+    primaryKey(): number | string;
+} & {
+    id(): number | string;
+    modelClassData(): {
+        name: string;
     };
-    /** orderedTableSettingColumns. */
-    orderedTableSettingColumns: (tableSetting: any) => any;
-    /** loadExistingOrCreateTableSettings. */
-    loadExistingOrCreateTableSettings: () => Promise<any>;
-    /** loadTableSetting. */
-    loadTableSetting: () => Promise<any>;
-    /** currentUserIdOrFallback. */
-    currentUserIdOrFallback(): any;
-    /** currentUserTypeOrFallback. */
-    currentUserTypeOrFallback(): any;
-    /** anonymouseUserId. */
-    anonymouseUserId(): any;
-    /** createInitialTableSetting. */
-    createInitialTableSetting: () => Promise<any>;
-    /** columnSaveData. */
-    columnSaveData(column: any, { identifier, position }: {
-        identifier: any;
-        position: any;
-    }): {
-        attribute_name: any;
-        identifier: any;
-        path: any;
-        position: any;
-        sort_key: any;
-        visible: any;
+};
+export type TableColumnDefinition = {
+    attribute?: string;
+    defaultVisible?: boolean;
+    identifier?: string;
+    label?: string;
+    path?: string[];
+    sortKey?: string;
+};
+export type TableSettingColumnRecord = {
+    id: () => number | string;
+    identifier: () => string;
+    path: () => string | null;
+    position: () => number;
+    sortKey: () => string | undefined;
+    visible: () => boolean | null;
+    attributeName: () => string | undefined;
+};
+export type TableSettingRecord = {
+    columns: () => {
+        loaded(): TableSettingColumnRecord[];
     };
-    /** updateTableSetting. */
-    updateTableSetting: (tableSetting: any) => Promise<any>;
-}
+    saveRaw: (data: FormData) => Promise<void>;
+};
+export type TableSettingRansackQuery = {
+    preload: (name: string) => TableSettingRansackQuery;
+    first: () => Promise<TableSettingRecord | undefined>;
+};
+export type TableSettingConstructor = new () => TableSettingRecord;
+export type TableSettingStatic = TableSettingConstructor & {
+    ransack(args: {
+        identifier_eq: string;
+        user_id_eq: number | string;
+        user_type_eq: string | null;
+    }): TableSettingRansackQuery;
+};
+export type TableSettingsTableLike = {
+    props: {
+        currentUser?: CurrentUserModel | null;
+    };
+    state: {
+        identifier: string;
+    };
+    columnsAsArray: () => TableColumnDefinition[];
+};
+export type PreparedColumnsResult = {
+    columns: Array<{
+        column: TableColumnDefinition | undefined;
+        tableSettingColumn: TableSettingColumnRecord;
+    }>;
+    preload: string[];
+};
+export type TableColumnSaveData = {
+    attribute_name: string | undefined;
+    id?: number | string | undefined;
+    identifier: string;
+    path: string[] | undefined;
+    position?: number;
+    sort_key: string | undefined;
+    visible?: boolean | null;
+    _destroy?: true;
+};
 //# sourceMappingURL=table-settings.d.ts.map

package/build/table/table-settings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table-settings.d.ts","sourceRoot":"/src/","sources":["table/table-settings.js"],"names":[],"mappings":"AAkBA,yCAAyC;AACzC;IACE,mBAAmB;IACnB;;OAGC;IAFC,WAAkB;IAIpB,4BAA4B;IAC5B,6BAQC;IADC,uBAA6D;IAG/D,eAAe;IACf,mBAA2C;IAE3C,4BAA4B;IAC5B,gCAIC;IAED,mBAAmB;IACnB,uBAA+D;IAE/D,kBAAkB;IAClB,sBAA6D;IAE7D,uBAAuB;IACvB,kBAAmB,iBAAY;;;MA0B9B;IAED,kCAAkC;IAClC,6BAA8B,iBAAY,SAKzC;IAED,yCAAyC;IACzC,sDAcC;IAED,wBAAwB;IACxB,qCAaC;IAED,+BAA+B;IAC/B,+BAMC;IAED,iCAAiC;IACjC,iCAMC;IAED,wBAAwB;IACxB,wBAUC;IAED,iCAAiC;IACjC,8CAsBC;IAED,sBAAsB;IACtB;;;;;;;;;;MASC;IAED,0BAA0B;IAC1B,qBAA4B,iBAAY,kBA4GvC;CACF"}
+{"version":3,"file":"table-settings.d.ts","sourceRoot":"/src/","sources":["table/table-settings.js"],"names":[],"mappings":"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"}

package/build/table/table-settings.js

@@ -1,3 +1,4 @@
+// @ts-check
 /* eslint-disable arrow-body-style, import/no-unresolved, sort-imports */
 import columnIdentifier from "./column-identifier.js";
 import columnVisible from "./column-visible.js";
@@ -11,11 +12,66 @@ import { TableSetting } from "models.js";
 // @ts-expect-error
 import { v4 as uuidv4 } from "uuid";
 const logger = new Logger({ name: "ApiMaker / TableSettings" });
+/** @typedef {import("../base-model.js").default & {id(): number | string, modelClassData(): {name: string}}} CurrentUserModel */
+/** @typedef {{attribute?: string, defaultVisible?: boolean, identifier?: string, label?: string, path?: string[], sortKey?: string}} TableColumnDefinition */
+/**
+ * @typedef {object} TableSettingColumnRecord
+ * @property {() => number | string} id
+ * @property {() => string} identifier
+ * @property {() => string | null} path
+ * @property {() => number} position
+ * @property {() => string | undefined} sortKey
+ * @property {() => boolean | null} visible
+ * @property {() => string | undefined} attributeName
+ */
+/**
+ * @typedef {object} TableSettingRecord
+ * @property {() => {loaded(): TableSettingColumnRecord[]}} columns
+ * @property {(data: FormData) => Promise<void>} saveRaw
+ */
+/**
+ * @typedef {object} TableSettingRansackQuery
+ * @property {(name: string) => TableSettingRansackQuery} preload
+ * @property {() => Promise<TableSettingRecord | undefined>} first
+ */
+/** @typedef {new () => TableSettingRecord} TableSettingConstructor */
+/**
+ * @typedef {TableSettingConstructor & {
+ *   ransack(args: {identifier_eq: string, user_id_eq: number | string, user_type_eq: string | null}): TableSettingRansackQuery
+ * }} TableSettingStatic
+ */
+/**
+ * @typedef {object} TableSettingsTableLike
+ * @property {{currentUser?: CurrentUserModel | null}} props
+ * @property {{identifier: string}} state
+ * @property {() => TableColumnDefinition[]} columnsAsArray
+ */
+/**
+ * @typedef {object} PreparedColumnsResult
+ * @property {Array<{column: TableColumnDefinition | undefined, tableSettingColumn: TableSettingColumnRecord}>} columns
+ * @property {string[]} preload
+ */
+/**
+ * @typedef {object} TableColumnSaveData
+ * @property {string | undefined} attribute_name
+ * @property {number | string | undefined} [id]
+ * @property {string} identifier
+ * @property {string[] | undefined} path
+ * @property {number} [position]
+ * @property {string | undefined} sort_key
+ * @property {boolean | null} [visible]
+ * @property {true} [_destroy]
+ */
+const TableSettingModel = /** @type {TableSettingStatic} */ (TableSetting);
 // Have a lock for each unique table identifier
-const tableSettingsLocks = {};
+const tableSettingsLocks = /** @type {Record<string, ReadersWriterLock>} */ ({});
 /** Persistent table settings manager. */
 export default class ApiMakerTableSettings {
-    /** Constructor. */
+    /**
+     * Constructor.
+     * @param {object} root0
+     * @param {TableSettingsTableLike} root0.table
+     */
     constructor({ table }) {
         this.table = table;
         this.setTableSettingsLock();
@@ -28,19 +84,23 @@ export default class ApiMakerTableSettings {
         }
         this.tableSettingsLock = digg(tableSettingsLocks, identifier);
     }
-    /** columns. */
+    /** @returns {TableColumnDefinition[]} */
     columns = () => this.table.columnsAsArray();
-    /** columnsWithPositions. */
+    /** @returns {Array<{column: TableColumnDefinition, identifier: string, position: number}>} */
     columnsWithPositions = () => {
         return this
             .columns()
             .map((column, columnIndex) => ({ column, identifier: columnIdentifier(column), position: columnIndex + 1 }));
     };
-    /** currentUser. */
+    /** @returns {CurrentUserModel | null} */
     currentUser = () => digg(this, "table", "props", "currentUser");
-    /** identifier. */
+    /** @returns {string} */
     identifier = () => digg(this, "table", "state", "identifier");
-    /** preparedColumns. */
+    /**
+     * preparedColumns.
+     * @param {TableSettingRecord} tableSetting
+     * @returns {PreparedColumnsResult | undefined}
+     */
     preparedColumns = (tableSetting) => {
         const columns = this.table.columnsAsArray();
         const ordered = this.orderedTableSettingColumns(tableSetting);
@@ -64,14 +124,18 @@ export default class ApiMakerTableSettings {
         }
         return result;
     };
-    /** orderedTableSettingColumns. */
+    /**
+     * orderedTableSettingColumns.
+     * @param {TableSettingRecord} tableSetting
+     * @returns {TableSettingColumnRecord[]}
+     */
     orderedTableSettingColumns = (tableSetting) => {
         return tableSetting
             .columns()
             .loaded()
             .sort((tableSettingColumn1, tableSettingColumn2) => tableSettingColumn1.position() - tableSettingColumn2.position());
     };
-    /** loadExistingOrCreateTableSettings. */
+    /** @returns {Promise<TableSettingRecord>} */
     loadExistingOrCreateTableSettings = async () => {
         return await this.tableSettingsLock.write(async () => {
             let tableSetting = await this.loadTableSetting();
@@ -86,11 +150,11 @@ export default class ApiMakerTableSettings {
             return tableSetting;
         });
     };
-    /** loadTableSetting. */
+    /** @returns {Promise<TableSettingRecord | undefined>} */
     loadTableSetting = async () => {
-        if (!TableSetting)
+        if (!TableSettingModel)
             throw new Error("TableSetting model isn't globally available");
-        const tableSetting = await TableSetting
+        const tableSetting = await TableSettingModel
             .ransack({
             identifier_eq: this.identifier(),
             user_id_eq: this.currentUserIdOrFallback(),
@@ -100,21 +164,30 @@ export default class ApiMakerTableSettings {
             .first();
         return tableSetting;
     };
-    /** currentUserIdOrFallback. */
+    /**
+     * currentUserIdOrFallback.
+     * @returns {number | string}
+     */
     currentUserIdOrFallback() {
         const currentUser = this.currentUser();
         if (currentUser)
             return currentUser.id();
         return this.anonymouseUserId();
     }
-    /** currentUserTypeOrFallback. */
+    /**
+     * currentUserTypeOrFallback.
+     * @returns {string | null}
+     */
     currentUserTypeOrFallback() {
         const currentUser = this.currentUser();
         if (currentUser)
             return digg(currentUser.modelClassData(), "name");
         return null;
     }
-    /** anonymouseUserId. */
+    /**
+     * anonymouseUserId.
+     * @returns {string}
+     */
     anonymouseUserId() {
         const variableName = `ApiMakerTableAnonymousUserId-${this.identifier()}`;
         if (!(variableName in localStorage)) {
@@ -123,7 +196,7 @@ export default class ApiMakerTableSettings {
         }
         return digg(localStorage, variableName);
     }
-    /** createInitialTableSetting. */
+    /** @returns {Promise<TableSettingRecord>} */
     createInitialTableSetting = async () => {
         const tableSettingData = {
             identifier: this.identifier(),
@@ -134,7 +207,7 @@ export default class ApiMakerTableSettings {
         for (const [columnKey, { column, identifier, position }] of this.columnsWithPositions().entries()) {
             tableSettingData.columns_attributes[columnKey] = this.columnSaveData(column, { identifier, position });
         }
-        const tableSetting = new TableSetting();
+        const tableSetting = new TableSettingModel();
         const tableSettingFormData = objectToFormData({ table_setting: tableSettingData });
         await tableSetting.saveRaw(tableSettingFormData);
         const reloadedTableSetting = await this.loadTableSetting();
@@ -142,7 +215,14 @@ export default class ApiMakerTableSettings {
             throw new Error("No reloadedTableSetting returned by loadTableSetting");
         return reloadedTableSetting;
     };
-    /** columnSaveData. */
+    /**
+     * columnSaveData.
+     * @param {TableColumnDefinition} column
+     * @param {object} root0
+     * @param {string} root0.identifier
+     * @param {number} root0.position
+     * @returns {TableColumnSaveData}
+     */
     columnSaveData(column, { identifier, position }) {
         return {
             attribute_name: column.attribute,
@@ -153,7 +233,11 @@ export default class ApiMakerTableSettings {
             visible: null
         };
     }
-    /** updateTableSetting. */
+    /**
+     * updateTableSetting.
+     * @param {TableSettingRecord} tableSetting
+     * @returns {Promise<TableSettingRecord>}
+     */
     updateTableSetting = async (tableSetting) => {
         const changedAttributesList = ["attributeName", "sortKey"];
         const columnsWithPositions = this.columnsWithPositions();
@@ -239,4 +323,4 @@ export default class ApiMakerTableSettings {
         return tableSetting;
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-settings.js","sourceRoot":"/src/","sources":["table/table-settings.js"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable arrow-body-style, import/no-unresolved, sort-imports */\nimport columnIdentifier from \"./column-identifier.js\"\nimport columnVisible from \"./column-visible.js\"\nimport {digg} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport Logger from \"../logger.js\"\nimport {ReadersWriterLock} from \"epic-locks\"\nimport {serialize as objectToFormData} from \"object-to-formdata\"\n// @ts-expect-error\nimport {TableSetting} from \"models.js\"\n// @ts-expect-error\nimport {v4 as uuidv4} from \"uuid\"\n\nconst logger = new Logger({name: \"ApiMaker / TableSettings\"})\n\n// Have a lock for each unique table identifier\nconst tableSettingsLocks = {}\n\n/** Persistent table settings manager. */\nexport default class ApiMakerTableSettings {\n  /** Constructor. */\n  constructor({table}) {\n    this.table = table\n    this.setTableSettingsLock()\n  }\n\n  /** setTableSettingsLock. */\n  setTableSettingsLock() {\n    const identifier = this.identifier()\n\n    if (!(identifier in tableSettingsLocks)) {\n      tableSettingsLocks[identifier] = new ReadersWriterLock()\n    }\n\n    this.tableSettingsLock = digg(tableSettingsLocks, identifier)\n  }\n\n  /** columns. */\n  columns = () => this.table.columnsAsArray()\n\n  /** columnsWithPositions. */\n  columnsWithPositions = () => {\n    return this\n      .columns()\n      .map((column, columnIndex) => ({column, identifier: columnIdentifier(column), position: columnIndex + 1}))\n  }\n\n  /** currentUser. */\n  currentUser = () => digg(this, \"table\", \"props\", \"currentUser\")\n\n  /** identifier. */\n  identifier = () => digg(this, \"table\", \"state\", \"identifier\")\n\n  /** preparedColumns. */\n  preparedColumns = (tableSetting) => {\n    const columns = this.table.columnsAsArray()\n    const ordered = this.orderedTableSettingColumns(tableSetting)\n    const result = {\n      columns: [],\n      preload: []\n    }\n\n    if (!ordered) return\n\n    for (const tableSettingColumn of ordered) {\n      const column = columns.find((column) => columnIdentifier(column) == tableSettingColumn.identifier())\n\n      result.columns.push({column, tableSettingColumn})\n\n      // Add needed preloads if column is visible\n      if (columnVisible(column, tableSettingColumn)) {\n        if (column.path) {\n          const preload = column.path.map((pathPart) => inflection.underscore(pathPart)).join(\".\")\n\n          if (!result.preload.includes(preload)) result.preload.push(preload)\n        }\n      }\n    }\n\n    return result\n  }\n\n  /** orderedTableSettingColumns. */\n  orderedTableSettingColumns = (tableSetting) => {\n    return tableSetting\n      .columns()\n      .loaded()\n      .sort((tableSettingColumn1, tableSettingColumn2) => tableSettingColumn1.position() - tableSettingColumn2.position())\n  }\n\n  /** loadExistingOrCreateTableSettings. */\n  loadExistingOrCreateTableSettings = async () => {\n    return await this.tableSettingsLock.write(async () => {\n      let tableSetting = await this.loadTableSetting()\n\n      if (tableSetting) {\n        tableSetting = await this.updateTableSetting(tableSetting)\n      } else {\n        tableSetting = await this.createInitialTableSetting()\n\n        if (!tableSetting) throw new Error(\"No tableSetting returned by createInitialTableSetting\")\n      }\n\n      return tableSetting\n    })\n  }\n\n  /** loadTableSetting. */\n  loadTableSetting = async () => {\n    if (!TableSetting) throw new Error(\"TableSetting model isn't globally available\")\n\n    const tableSetting = await TableSetting\n      .ransack({\n        identifier_eq: this.identifier(),\n        user_id_eq: this.currentUserIdOrFallback(),\n        user_type_eq: this.currentUserTypeOrFallback()\n      })\n      .preload(\"columns\")\n      .first()\n\n    return tableSetting\n  }\n\n  /** currentUserIdOrFallback. */\n  currentUserIdOrFallback() {\n    const currentUser = this.currentUser()\n\n    if (currentUser) return currentUser.id()\n\n    return this.anonymouseUserId()\n  }\n\n  /** currentUserTypeOrFallback. */\n  currentUserTypeOrFallback() {\n    const currentUser = this.currentUser()\n\n    if (currentUser) return digg(currentUser.modelClassData(), \"name\")\n\n    return null\n  }\n\n  /** anonymouseUserId. */\n  anonymouseUserId() {\n    const variableName = `ApiMakerTableAnonymousUserId-${this.identifier()}`\n\n    if (!(variableName in localStorage)) {\n      const generatedId = uuidv4()\n\n      localStorage[variableName] = generatedId\n    }\n\n    return digg(localStorage, variableName)\n  }\n\n  /** createInitialTableSetting. */\n  createInitialTableSetting = async () => {\n    const tableSettingData = {\n      identifier: this.identifier(),\n      user_id: this.currentUserIdOrFallback(),\n      user_type: this.currentUserTypeOrFallback(),\n      columns_attributes: {}\n    }\n\n    for (const [columnKey, {column, identifier, position}] of this.columnsWithPositions().entries()) {\n      tableSettingData.columns_attributes[columnKey] = this.columnSaveData(column, {identifier, position})\n    }\n\n    const tableSetting = new TableSetting()\n    const tableSettingFormData = objectToFormData({table_setting: tableSettingData})\n\n    await tableSetting.saveRaw(tableSettingFormData)\n\n    const reloadedTableSetting = await this.loadTableSetting()\n\n    if (!reloadedTableSetting) throw new Error(\"No reloadedTableSetting returned by loadTableSetting\")\n\n    return reloadedTableSetting\n  }\n\n  /** columnSaveData. */\n  columnSaveData(column, {identifier, position}) {\n    return {\n      attribute_name: column.attribute,\n      identifier,\n      path: column.path,\n      position,\n      sort_key: column.sortKey,\n      visible: null\n    }\n  }\n\n  /** updateTableSetting. */\n  updateTableSetting = async (tableSetting) => {\n    const changedAttributesList = [\"attributeName\", \"sortKey\"]\n    const columnsWithPositions = this.columnsWithPositions()\n    const columnsData = {}\n    const tableSettingData = {columns_attributes: columnsData}\n    const existingColumns = tableSetting.columns().loaded()\n    let columnsKeyCount = 0\n    let changed = false\n\n    // Add missing columns\n    for (const {column, identifier, position} of columnsWithPositions) {\n      const tableSettingColumn = existingColumns.find((tableSettingColumn) => tableSettingColumn.identifier() == identifier)\n\n      if (!tableSettingColumn) {\n        const columnKey = ++columnsKeyCount\n\n        columnsData[columnKey] = this.columnSaveData(\n          column,\n          {\n            identifier,\n            position\n          }\n        )\n\n        logger.debug(() => `Changed because of new column at position ${position}: ${column.label}`)\n        changed = true\n      }\n    }\n\n    // Update existing columns to match the current column metadata without overwriting user-saved order.\n    for (const {column, identifier} of columnsWithPositions) {\n      const tableSettingColumn = existingColumns.find((tableSettingColumn) => tableSettingColumn.identifier() == identifier)\n\n      if (tableSettingColumn) {\n        let columnChanged = false\n\n        for (const changedAttribute of changedAttributesList) {\n          let columnAttributeName\n\n          if (changedAttribute == \"attributeName\") {\n            columnAttributeName = \"attribute\"\n          } else {\n            columnAttributeName = changedAttribute\n          }\n\n          const oldAttributeValue = tableSettingColumn[changedAttribute]()\n          const newAttributeValue = column[columnAttributeName]\n\n          if (oldAttributeValue != newAttributeValue) {\n            logger.debug(() => `${changedAttribute} changed from ${oldAttributeValue} to ${newAttributeValue} on column: ${column.label}`)\n            columnChanged = true\n          }\n        }\n\n        const columnPathAsString = JSON.stringify(column.path)\n        const tableSettingColumnPathAsString = tableSettingColumn.path()\n\n        if (columnPathAsString != tableSettingColumnPathAsString) {\n          logger.debug(() => `Path changed on ${column.label} from ${columnPathAsString} to ${tableSettingColumnPathAsString}`)\n          columnChanged = true\n        }\n\n        if (columnChanged) {\n          const columnKey = ++columnsKeyCount\n\n          changed = true\n          columnsData[columnKey] = {\n            attribute_name: column.attribute,\n            id: tableSettingColumn.id(),\n            path: column.path,\n            sort_key: column.sortKey\n          }\n        }\n      }\n    }\n\n    for (const tableSettingColumn of existingColumns) {\n      const columnExists = columnsWithPositions.find(({identifier}) => identifier == tableSettingColumn.identifier())\n\n      if (!columnExists) {\n        // Removed saved columns no longer found.\n        const columnKey = ++columnsKeyCount\n\n        columnsData[columnKey] = {\n          id: tableSettingColumn.id(),\n          _destroy: true\n        }\n        changed = true\n\n        logger.debug(() => `Column got removed: ${tableSettingColumn.identifier()}`)\n      }\n    }\n\n    if (changed) {\n      const tableSettingFormData = objectToFormData({table_setting: tableSettingData})\n\n      await tableSetting.saveRaw(tableSettingFormData)\n\n      // Re-read the table setting after structural updates so prepared columns use the\n      // persisted column list rather than the stale pre-save association cache.\n      const reloadedTableSetting = await this.loadTableSetting()\n\n      if (!reloadedTableSetting) throw new Error(\"No reloadedTableSetting returned by loadTableSetting\")\n\n      return reloadedTableSetting\n    }\n\n    return tableSetting\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-settings.js","sourceRoot":"/src/","sources":["table/table-settings.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable arrow-body-style, import/no-unresolved, sort-imports */\nimport columnIdentifier from \"./column-identifier.js\"\nimport columnVisible from \"./column-visible.js\"\nimport {digg} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport Logger from \"../logger.js\"\nimport {ReadersWriterLock} from \"epic-locks\"\nimport {serialize as objectToFormData} from \"object-to-formdata\"\n// @ts-expect-error\nimport {TableSetting} from \"models.js\"\n// @ts-expect-error\nimport {v4 as uuidv4} from \"uuid\"\n\nconst logger = new Logger({name: \"ApiMaker / TableSettings\"})\n\n/** @typedef {import(\"../base-model.js\").default & {id(): number | string, modelClassData(): {name: string}}} CurrentUserModel */\n/** @typedef {{attribute?: string, defaultVisible?: boolean, identifier?: string, label?: string, path?: string[], sortKey?: string}} TableColumnDefinition */\n/**\n * @typedef {object} TableSettingColumnRecord\n * @property {() => number | string} id\n * @property {() => string} identifier\n * @property {() => string | null} path\n * @property {() => number} position\n * @property {() => string | undefined} sortKey\n * @property {() => boolean | null} visible\n * @property {() => string | undefined} attributeName\n */\n/**\n * @typedef {object} TableSettingRecord\n * @property {() => {loaded(): TableSettingColumnRecord[]}} columns\n * @property {(data: FormData) => Promise<void>} saveRaw\n */\n/**\n * @typedef {object} TableSettingRansackQuery\n * @property {(name: string) => TableSettingRansackQuery} preload\n * @property {() => Promise<TableSettingRecord | undefined>} first\n */\n/** @typedef {new () => TableSettingRecord} TableSettingConstructor */\n/**\n * @typedef {TableSettingConstructor & {\n *   ransack(args: {identifier_eq: string, user_id_eq: number | string, user_type_eq: string | null}): TableSettingRansackQuery\n * }} TableSettingStatic\n */\n/**\n * @typedef {object} TableSettingsTableLike\n * @property {{currentUser?: CurrentUserModel | null}} props\n * @property {{identifier: string}} state\n * @property {() => TableColumnDefinition[]} columnsAsArray\n */\n/**\n * @typedef {object} PreparedColumnsResult\n * @property {Array<{column: TableColumnDefinition | undefined, tableSettingColumn: TableSettingColumnRecord}>} columns\n * @property {string[]} preload\n */\n/**\n * @typedef {object} TableColumnSaveData\n * @property {string | undefined} attribute_name\n * @property {number | string | undefined} [id]\n * @property {string} identifier\n * @property {string[] | undefined} path\n * @property {number} [position]\n * @property {string | undefined} sort_key\n * @property {boolean | null} [visible]\n * @property {true} [_destroy]\n */\nconst TableSettingModel = /** @type {TableSettingStatic} */ (TableSetting)\n\n// Have a lock for each unique table identifier\nconst tableSettingsLocks = /** @type {Record<string, ReadersWriterLock>} */ ({})\n\n/** Persistent table settings manager. */\nexport default class ApiMakerTableSettings {\n  /**\n   * Constructor.\n   * @param {object} root0\n   * @param {TableSettingsTableLike} root0.table\n   */\n  constructor({table}) {\n    this.table = table\n    this.setTableSettingsLock()\n  }\n\n  /** setTableSettingsLock. */\n  setTableSettingsLock() {\n    const identifier = this.identifier()\n\n    if (!(identifier in tableSettingsLocks)) {\n      tableSettingsLocks[identifier] = new ReadersWriterLock()\n    }\n\n    this.tableSettingsLock = digg(tableSettingsLocks, identifier)\n  }\n\n  /** @returns {TableColumnDefinition[]} */\n  columns = () => this.table.columnsAsArray()\n\n  /** @returns {Array<{column: TableColumnDefinition, identifier: string, position: number}>} */\n  columnsWithPositions = () => {\n    return this\n      .columns()\n      .map((column, columnIndex) => ({column, identifier: columnIdentifier(column), position: columnIndex + 1}))\n  }\n\n  /** @returns {CurrentUserModel | null} */\n  currentUser = () => digg(this, \"table\", \"props\", \"currentUser\")\n\n  /** @returns {string} */\n  identifier = () => digg(this, \"table\", \"state\", \"identifier\")\n\n  /**\n   * preparedColumns.\n   * @param {TableSettingRecord} tableSetting\n   * @returns {PreparedColumnsResult | undefined}\n   */\n  preparedColumns = (tableSetting) => {\n    const columns = this.table.columnsAsArray()\n    const ordered = this.orderedTableSettingColumns(tableSetting)\n    const result = {\n      columns: [],\n      preload: []\n    }\n\n    if (!ordered) return\n\n    for (const tableSettingColumn of ordered) {\n      const column = columns.find((column) => columnIdentifier(column) == tableSettingColumn.identifier())\n\n      result.columns.push({column, tableSettingColumn})\n\n      // Add needed preloads if column is visible\n      if (columnVisible(column, tableSettingColumn)) {\n        if (column.path) {\n          const preload = column.path.map((pathPart) => inflection.underscore(pathPart)).join(\".\")\n\n          if (!result.preload.includes(preload)) result.preload.push(preload)\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * orderedTableSettingColumns.\n   * @param {TableSettingRecord} tableSetting\n   * @returns {TableSettingColumnRecord[]}\n   */\n  orderedTableSettingColumns = (tableSetting) => {\n    return tableSetting\n      .columns()\n      .loaded()\n      .sort((tableSettingColumn1, tableSettingColumn2) => tableSettingColumn1.position() - tableSettingColumn2.position())\n  }\n\n  /** @returns {Promise<TableSettingRecord>} */\n  loadExistingOrCreateTableSettings = async () => {\n    return await this.tableSettingsLock.write(async () => {\n      let tableSetting = await this.loadTableSetting()\n\n      if (tableSetting) {\n        tableSetting = await this.updateTableSetting(tableSetting)\n      } else {\n        tableSetting = await this.createInitialTableSetting()\n\n        if (!tableSetting) throw new Error(\"No tableSetting returned by createInitialTableSetting\")\n      }\n\n      return tableSetting\n    })\n  }\n\n  /** @returns {Promise<TableSettingRecord | undefined>} */\n  loadTableSetting = async () => {\n    if (!TableSettingModel) throw new Error(\"TableSetting model isn't globally available\")\n\n    const tableSetting = await TableSettingModel\n      .ransack({\n        identifier_eq: this.identifier(),\n        user_id_eq: this.currentUserIdOrFallback(),\n        user_type_eq: this.currentUserTypeOrFallback()\n      })\n      .preload(\"columns\")\n      .first()\n\n    return tableSetting\n  }\n\n  /**\n   * currentUserIdOrFallback.\n   * @returns {number | string}\n   */\n  currentUserIdOrFallback() {\n    const currentUser = this.currentUser()\n\n    if (currentUser) return currentUser.id()\n\n    return this.anonymouseUserId()\n  }\n\n  /**\n   * currentUserTypeOrFallback.\n   * @returns {string | null}\n   */\n  currentUserTypeOrFallback() {\n    const currentUser = this.currentUser()\n\n    if (currentUser) return digg(currentUser.modelClassData(), \"name\")\n\n    return null\n  }\n\n  /**\n   * anonymouseUserId.\n   * @returns {string}\n   */\n  anonymouseUserId() {\n    const variableName = `ApiMakerTableAnonymousUserId-${this.identifier()}`\n\n    if (!(variableName in localStorage)) {\n      const generatedId = uuidv4()\n\n      localStorage[variableName] = generatedId\n    }\n\n    return digg(localStorage, variableName)\n  }\n\n  /** @returns {Promise<TableSettingRecord>} */\n  createInitialTableSetting = async () => {\n    const tableSettingData = {\n      identifier: this.identifier(),\n      user_id: this.currentUserIdOrFallback(),\n      user_type: this.currentUserTypeOrFallback(),\n      columns_attributes: {}\n    }\n\n    for (const [columnKey, {column, identifier, position}] of this.columnsWithPositions().entries()) {\n      tableSettingData.columns_attributes[columnKey] = this.columnSaveData(column, {identifier, position})\n    }\n\n    const tableSetting = new TableSettingModel()\n    const tableSettingFormData = objectToFormData({table_setting: tableSettingData})\n\n    await tableSetting.saveRaw(tableSettingFormData)\n\n    const reloadedTableSetting = await this.loadTableSetting()\n\n    if (!reloadedTableSetting) throw new Error(\"No reloadedTableSetting returned by loadTableSetting\")\n\n    return reloadedTableSetting\n  }\n\n  /**\n   * columnSaveData.\n   * @param {TableColumnDefinition} column\n   * @param {object} root0\n   * @param {string} root0.identifier\n   * @param {number} root0.position\n   * @returns {TableColumnSaveData}\n   */\n  columnSaveData(column, {identifier, position}) {\n    return {\n      attribute_name: column.attribute,\n      identifier,\n      path: column.path,\n      position,\n      sort_key: column.sortKey,\n      visible: null\n    }\n  }\n\n  /**\n   * updateTableSetting.\n   * @param {TableSettingRecord} tableSetting\n   * @returns {Promise<TableSettingRecord>}\n   */\n  updateTableSetting = async (tableSetting) => {\n    const changedAttributesList = [\"attributeName\", \"sortKey\"]\n    const columnsWithPositions = this.columnsWithPositions()\n    const columnsData = {}\n    const tableSettingData = {columns_attributes: columnsData}\n    const existingColumns = tableSetting.columns().loaded()\n    let columnsKeyCount = 0\n    let changed = false\n\n    // Add missing columns\n    for (const {column, identifier, position} of columnsWithPositions) {\n      const tableSettingColumn = existingColumns.find((tableSettingColumn) => tableSettingColumn.identifier() == identifier)\n\n      if (!tableSettingColumn) {\n        const columnKey = ++columnsKeyCount\n\n        columnsData[columnKey] = this.columnSaveData(\n          column,\n          {\n            identifier,\n            position\n          }\n        )\n\n        logger.debug(() => `Changed because of new column at position ${position}: ${column.label}`)\n        changed = true\n      }\n    }\n\n    // Update existing columns to match the current column metadata without overwriting user-saved order.\n    for (const {column, identifier} of columnsWithPositions) {\n      const tableSettingColumn = existingColumns.find((tableSettingColumn) => tableSettingColumn.identifier() == identifier)\n\n      if (tableSettingColumn) {\n        let columnChanged = false\n\n        for (const changedAttribute of changedAttributesList) {\n          let columnAttributeName\n\n          if (changedAttribute == \"attributeName\") {\n            columnAttributeName = \"attribute\"\n          } else {\n            columnAttributeName = changedAttribute\n          }\n\n          const oldAttributeValue = tableSettingColumn[changedAttribute]()\n          const newAttributeValue = column[columnAttributeName]\n\n          if (oldAttributeValue != newAttributeValue) {\n            logger.debug(() => `${changedAttribute} changed from ${oldAttributeValue} to ${newAttributeValue} on column: ${column.label}`)\n            columnChanged = true\n          }\n        }\n\n        const columnPathAsString = JSON.stringify(column.path)\n        const tableSettingColumnPathAsString = tableSettingColumn.path()\n\n        if (columnPathAsString != tableSettingColumnPathAsString) {\n          logger.debug(() => `Path changed on ${column.label} from ${columnPathAsString} to ${tableSettingColumnPathAsString}`)\n          columnChanged = true\n        }\n\n        if (columnChanged) {\n          const columnKey = ++columnsKeyCount\n\n          changed = true\n          columnsData[columnKey] = {\n            attribute_name: column.attribute,\n            id: tableSettingColumn.id(),\n            path: column.path,\n            sort_key: column.sortKey\n          }\n        }\n      }\n    }\n\n    for (const tableSettingColumn of existingColumns) {\n      const columnExists = columnsWithPositions.find(({identifier}) => identifier == tableSettingColumn.identifier())\n\n      if (!columnExists) {\n        // Removed saved columns no longer found.\n        const columnKey = ++columnsKeyCount\n\n        columnsData[columnKey] = {\n          id: tableSettingColumn.id(),\n          _destroy: true\n        }\n        changed = true\n\n        logger.debug(() => `Column got removed: ${tableSettingColumn.identifier()}`)\n      }\n    }\n\n    if (changed) {\n      const tableSettingFormData = objectToFormData({table_setting: tableSettingData})\n\n      await tableSetting.saveRaw(tableSettingFormData)\n\n      // Re-read the table setting after structural updates so prepared columns use the\n      // persisted column list rather than the stale pre-save association cache.\n      const reloadedTableSetting = await this.loadTableSetting()\n\n      if (!reloadedTableSetting) throw new Error(\"No reloadedTableSetting returned by loadTableSetting\")\n\n      return reloadedTableSetting\n    }\n\n    return tableSetting\n  }\n}\n"]}