lucid-extension-sdk 0.0.440 → 0.0.442

package/commandtypes.d.ts

@@ -53,6 +53,7 @@ export declare const enum CommandName {
     CreateCollection = "cc",
     CreateDataSource = "cds",
     CreateDocumentElement = "cde",
+    CreateGraph = "cgr",
     CreateGroup = "cg",
     CreateLine = "cl",
     CreatePage = "cp",
@@ -282,6 +283,10 @@ export type CommandArgs = {
         query: CreateDocumentElementQuery;
         result: CreateDocumentElementResult;
     };
+    [CommandName.CreateGraph]: {
+        query: CreateGraphQuery;
+        result: CreateGraphResult;
+    };
     [CommandName.CreateGroup]: {
         query: CreateGroupQuery;
         result: CreateGroupResult;
@@ -779,6 +784,8 @@ export type SerializedFieldConfiguration = {
     'cfds'?: SerializedCustomFieldDisplaySettings;
     /** Non-customizable fields */
     'ncf'?: string[] | undefined;
+    /** Callback to get fields to edit related to a field passed as an argument */
+    'gfte'?: string | undefined;
 };
 export type AddCardIntegrationQuery = {
     /** Title/name */
@@ -928,6 +935,8 @@ export type AddCardIntegrationQuery = {
      * Whether the user can edit an item in the data source.
      */
     'cei'?: string | undefined;
+    /** getAdditionalPanelTabsForCard -- Cards' additional details via tabs in panel */
+    'gaptfc'?: string | undefined;
 };
 export type AddCardIntegrationResult = undefined;
 /** @ignore */
@@ -1196,6 +1205,20 @@ export type CreateGroupQuery = {
     'i': string[];
 };
 export type CreateGroupResult = string;
+export type CreateGraphQuery = {
+    /**
+     * By default, we add the graph to the current page. If specified, the
+     * graph will instead be created as a direct child of the given page.
+     */
+    'p'?: string | undefined;
+    /** Type of graph to create, e.g. 'BarGraphCollectionBlock' or 'LineGraphCollectionBlock' */
+    't': string;
+    /** ID of the collection */
+    'col': string;
+    /** Title of the graph */
+    'ti': string;
+};
+export type CreateGraphResult = Promise<string>;
 export type CreateCollectionFieldDefinition = {
     /** Name of the field */
     'n': string;
@@ -1270,6 +1293,9 @@ export type DataActionQuery = {
     's'?: string | undefined;
     /** Data Connector Name */
     'n': string;
+    /**Requested Primary keys or keys of items we
+     * are requesting info for in the data action */
+    'rpk'?: Record<string, string[]> | undefined;
 };
 export type RawDataActionResult = {
     /** The external service responded with this code */

package/core/cardintegration/cardfielddisplaysettings.d.ts

@@ -29,6 +29,12 @@ export declare enum FieldDisplayType {
      * Given a URL, display a small image cropped into a square in the lower-left of the card.
      */
     SquareImageBadge = "SquareImageBadge",
+    /**
+     * Displays an icon and value as a badge in the bottom-left of the card. Takes an object containing an iconUrl
+     * and value. If value is a string longer than 20 characters, it will be truncated to be a maximum of 20 chars
+     * appending '...' to the given value. If value is a number higher than 999, displays 999.
+     */
+    TagBadge = "TagBadge",
     /**
      * Given a date, display a small calendar icon alongside a very short version of the date
      * as a string, e.g. "Sep 9"
@@ -80,7 +86,12 @@ export declare enum OnClickHandlerKeys {
      * Display a panel on the canvas when a stencil is clicked, showing editable input fields for the values that
      * calculate what is shown on the stencil
      */
-    EditFieldsStencilPanel = "EditFieldsStencilPanel"
+    EditFieldsStencilPanel = "EditFieldsStencilPanel",
+    /**
+     * Display a panel on the canvas when a stencil is clicked, showing editable input fields for the values that
+     * calculate what is shown on the stencil
+     */
+    DataRowStencilPanel = "DataRowStencilPanel"
 }
 export declare const isOnClickHandlerKey: (x: unknown) => x is OnClickHandlerKeys;
 export type ImageBadgeSettings = {

package/core/cardintegration/cardfielddisplaysettings.js

@@ -34,6 +34,12 @@ var FieldDisplayType;
      * Given a URL, display a small image cropped into a square in the lower-left of the card.
      */
     FieldDisplayType["SquareImageBadge"] = "SquareImageBadge";
+    /**
+     * Displays an icon and value as a badge in the bottom-left of the card. Takes an object containing an iconUrl
+     * and value. If value is a string longer than 20 characters, it will be truncated to be a maximum of 20 chars
+     * appending '...' to the given value. If value is a number higher than 999, displays 999.
+     */
+    FieldDisplayType["TagBadge"] = "TagBadge";
     /**
      * Given a date, display a small calendar icon alongside a very short version of the date
      * as a string, e.g. "Sep 9"
@@ -87,6 +93,11 @@ var OnClickHandlerKeys;
      * calculate what is shown on the stencil
      */
     OnClickHandlerKeys["EditFieldsStencilPanel"] = "EditFieldsStencilPanel";
+    /**
+     * Display a panel on the canvas when a stencil is clicked, showing editable input fields for the values that
+     * calculate what is shown on the stencil
+     */
+    OnClickHandlerKeys["DataRowStencilPanel"] = "DataRowStencilPanel";
 })(OnClickHandlerKeys || (exports.OnClickHandlerKeys = OnClickHandlerKeys = {}));
 exports.isOnClickHandlerKey = (0, validators_1.enumValidator)(OnClickHandlerKeys);
 const isImageBadgeSettings = (0, validators_1.objectValidator)({

package/core/cardintegration/cardintegrationparams.d.ts

@@ -112,7 +112,9 @@ export interface ImportFromSerializedFieldsCallbackParam {
 }
 /** @ignore */
 export interface CanEditItemsParam {
-    'ek': string;
-    'dk'?: string;
+    'i': Array<{
+        'pk': string;
+        'cid': string;
+    }>;
 }
 export {};

package/core/cardintegration/cardpaneltabs/tab.d.ts

@@ -0,0 +1,23 @@
+import { LucidCardPanelListTab, SerializedLucidCardPanelListTab } from './tabs/listtab';
+/**
+ * @experimental Information to represent a tab, in the card details panel.
+ * There exist various kinds of tabs in the panel.
+ * Each kind has its own corresponding information and type definition, found in the `tabs` subdirectory.
+ */
+export type LucidCardPanelTab = LucidCardPanelListTab;
+/** @ignore */
+export declare const isValidLucidCardPanelTab: (x: any) => x is import("../../guards").DestructureGuardedTypeObj<{
+    type: (x: unknown) => x is "LucidCardPanelListTab";
+    label: typeof import("../../checks").isString;
+}>;
+/** @ignore */
+export type SerializedLucidCardPanelTab = SerializedLucidCardPanelListTab;
+/** @ignore */
+export declare const isValidSerializedLucidCardPanelTab: (x: any) => x is import("../../guards").DestructureGuardedTypeObj<{
+    type: (x: unknown) => x is "lcplt";
+    l: typeof import("../../checks").isString;
+}>;
+/** @ignore */
+export declare function serializeLucidCardPanelTab(concrete: LucidCardPanelTab): SerializedLucidCardPanelTab;
+/** @ignore */
+export declare function deserializeLucidCardPanelTab(serialized: SerializedLucidCardPanelTab): LucidCardPanelTab;

package/core/cardintegration/cardpaneltabs/tab.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeLucidCardPanelTab = exports.serializeLucidCardPanelTab = exports.isValidSerializedLucidCardPanelTab = exports.isValidLucidCardPanelTab = void 0;
+const assertnever_1 = require("../../assertnever");
+const validators_1 = require("../../validators/validators");
+const listtab_1 = require("./tabs/listtab");
+/** @ignore */
+exports.isValidLucidCardPanelTab = (0, validators_1.someValidator)(listtab_1.isValidLucidCardPanelListTab);
+/** @ignore */
+exports.isValidSerializedLucidCardPanelTab = (0, validators_1.someValidator)(listtab_1.isValidSerializedLucidCardPanelListTab);
+/** @ignore */
+function serializeLucidCardPanelTab(concrete) {
+    switch (concrete.type) {
+        case 'LucidCardPanelListTab':
+            return (0, listtab_1.serializeLucidCardPanelListTab)(concrete);
+        default:
+            (0, assertnever_1.assertNever)(concrete.type);
+    }
+}
+exports.serializeLucidCardPanelTab = serializeLucidCardPanelTab;
+/** @ignore */
+function deserializeLucidCardPanelTab(serialized) {
+    switch (serialized.type) {
+        case 'lcplt':
+            return (0, listtab_1.deserializeLucidCardPanelListTab)(serialized);
+        default:
+            (0, assertnever_1.assertNever)(serialized.type);
+    }
+}
+exports.deserializeLucidCardPanelTab = deserializeLucidCardPanelTab;

package/core/cardintegration/cardpaneltabs/tabs/listtab.d.ts

@@ -0,0 +1,29 @@
+import { isString } from '../../../checks';
+/**
+ * @ignore Will be implemented soon.
+ * Information that represents a list of items.
+ * (Currently blank and unimplemented.)
+ */
+export interface LucidCardPanelListTab {
+    type: 'LucidCardPanelListTab';
+    label: string;
+}
+/** @ignore */
+export declare const isValidLucidCardPanelListTab: (subject: unknown) => subject is import("../../../guards").DestructureGuardedTypeObj<{
+    type: (x: unknown) => x is "LucidCardPanelListTab";
+    label: typeof isString;
+}>;
+/** @ignore */
+export interface SerializedLucidCardPanelListTab {
+    'type': 'lcplt';
+    'l': string;
+}
+/** @ignore */
+export declare const isValidSerializedLucidCardPanelListTab: (subject: unknown) => subject is import("../../../guards").DestructureGuardedTypeObj<{
+    type: (x: unknown) => x is "lcplt";
+    l: typeof isString;
+}>;
+/** @ignore */
+export declare function serializeLucidCardPanelListTab(concrete: LucidCardPanelListTab): SerializedLucidCardPanelListTab;
+/** @ignore */
+export declare function deserializeLucidCardPanelListTab(serialized: SerializedLucidCardPanelListTab): LucidCardPanelListTab;

package/core/cardintegration/cardpaneltabs/tabs/listtab.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeLucidCardPanelListTab = exports.serializeLucidCardPanelListTab = exports.isValidSerializedLucidCardPanelListTab = exports.isValidLucidCardPanelListTab = void 0;
+const checks_1 = require("../../../checks");
+const validators_1 = require("../../../validators/validators");
+/** @ignore */
+exports.isValidLucidCardPanelListTab = (0, validators_1.objectValidator)({
+    type: (0, validators_1.someValue)('LucidCardPanelListTab'),
+    label: checks_1.isString,
+});
+/** @ignore */
+exports.isValidSerializedLucidCardPanelListTab = (0, validators_1.objectValidator)({
+    'type': (0, validators_1.someValue)('lcplt'),
+    'l': checks_1.isString,
+});
+/** @ignore */
+function serializeLucidCardPanelListTab(concrete) {
+    return {
+        'type': 'lcplt',
+        'l': concrete.label,
+    };
+}
+exports.serializeLucidCardPanelListTab = serializeLucidCardPanelListTab;
+/** @ignore */
+function deserializeLucidCardPanelListTab(serialized) {
+    return {
+        type: 'LucidCardPanelListTab',
+        label: serialized['l'],
+    };
+}
+exports.deserializeLucidCardPanelListTab = deserializeLucidCardPanelListTab;

package/core/cardintegration/cardpaneltabs/tabs.d.ts

@@ -0,0 +1,37 @@
+import { AddCardIntegrationQuery } from '../../../commandtypes';
+import { DataItemProxy } from '../../../data/dataitemproxy';
+import { EditorClient, PostMessageType } from '../../../editorclient';
+import { DataItemCallbackParam } from '../cardintegrationparams';
+import { LucidCardPanelTab, SerializedLucidCardPanelTab } from './tab';
+/**
+ * @experimental Information to represent a collection of tabs, in the card details panel.
+ */
+export type LucidCardPanelTabs = LucidCardPanelTab[];
+/** @ignore */
+export declare const areValidLucidCardPanelTabs: (p1: unknown) => p1 is import("../../guards").DestructureGuardedTypeObj<{
+    type: (x: unknown) => x is "LucidCardPanelListTab";
+    label: typeof import("../../checks").isString;
+}>[];
+/** @ignore */
+export type SerializedLucidCardPanelTabs = SerializedLucidCardPanelTab[];
+/** @ignore */
+export declare const areValidSerializedLucidCardPanelTabs: (p1: unknown) => p1 is import("../../guards").DestructureGuardedTypeObj<{
+    type: (x: unknown) => x is "lcplt";
+    l: typeof import("../../checks").isString;
+}>[];
+/** @ignore */
+export declare function serializeLucidCardPanelTabs(concrete: LucidCardPanelTabs): SerializedLucidCardPanelTabs;
+/** @ignore */
+export declare function deserializeLucidCardPanelTabs(serialized: SerializedLucidCardPanelTabs): LucidCardPanelTabs;
+/**
+ * @experimental Callback function that, from a data item, derives additional tabs to show in the card details panel.
+ */
+export type AdditionalPanelTabsCallback = (dataItemProxy: DataItemProxy) => Promise<LucidCardPanelTabs | undefined>;
+/** @ignore */
+export type AdditionalPanelTabsCallbackInternal = (dataItemCallbackParam: DataItemCallbackParam) => Promise<SerializedLucidCardPanelTabs | undefined>;
+/** @ignore */
+export declare function registerGetAdditionalPanelTabsForCardCallback(client: EditorClient, tabsCallback: AdditionalPanelTabsCallback, serialized: AddCardIntegrationQuery, actionName: string): void;
+/** @ignore */
+export type TabsCallbackInternal = (dataSourceId: string, collectionId: string, primaryKey: string) => Promise<LucidCardPanelTabs | undefined>;
+/** @ignore */
+export declare function deserializeTabsCallback(callbackHookName: string, postMessage: PostMessageType): TabsCallbackInternal;

package/core/cardintegration/cardpaneltabs/tabs.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeTabsCallback = exports.registerGetAdditionalPanelTabsForCardCallback = exports.deserializeLucidCardPanelTabs = exports.serializeLucidCardPanelTabs = exports.areValidSerializedLucidCardPanelTabs = exports.areValidLucidCardPanelTabs = void 0;
+const collectionproxy_1 = require("../../../data/collectionproxy");
+const dataitemproxy_1 = require("../../../data/dataitemproxy");
+const validators_1 = require("../../validators/validators");
+const tab_1 = require("./tab");
+/** @ignore */
+exports.areValidLucidCardPanelTabs = (0, validators_1.arrayValidator)(tab_1.isValidLucidCardPanelTab);
+/** @ignore */
+exports.areValidSerializedLucidCardPanelTabs = (0, validators_1.arrayValidator)(tab_1.isValidSerializedLucidCardPanelTab);
+/** @ignore */
+function serializeLucidCardPanelTabs(concrete) {
+    return concrete.map(tab_1.serializeLucidCardPanelTab);
+}
+exports.serializeLucidCardPanelTabs = serializeLucidCardPanelTabs;
+/** @ignore */
+function deserializeLucidCardPanelTabs(serialized) {
+    return serialized.map(tab_1.deserializeLucidCardPanelTab);
+}
+exports.deserializeLucidCardPanelTabs = deserializeLucidCardPanelTabs;
+/** @ignore */
+function registerGetAdditionalPanelTabsForCardCallback(client, tabsCallback, serialized, actionName) {
+    serialized['gaptfc'] = actionName;
+    const serializedAction = async ({ 'd': dataSourceId, 'c': collectionId, 'p': primaryKey, }) => {
+        try {
+            const collectionProxy = new collectionproxy_1.CollectionProxy(collectionId, client);
+            const dataItemProxy = new dataitemproxy_1.DataItemProxy(primaryKey, collectionProxy, client);
+            const result = await tabsCallback(dataItemProxy);
+            if (result === undefined) {
+                return undefined;
+            }
+            return serializeLucidCardPanelTabs(result);
+        }
+        catch (err) {
+            return undefined;
+        }
+    };
+    client.registerAction(actionName, serializedAction);
+}
+exports.registerGetAdditionalPanelTabsForCardCallback = registerGetAdditionalPanelTabsForCardCallback;
+/** @ignore */
+function deserializeTabsCallback(callbackHookName, postMessage) {
+    // Serializes, runs callback, and deserializes the result
+    const wrappedCallback = async (dataSourceId, collectionId, primaryKey) => {
+        const callbackParam = {
+            'd': dataSourceId,
+            'c': collectionId,
+            'p': primaryKey,
+        };
+        const serializedTabs = await postMessage(Object.assign({ 'id': callbackHookName }, callbackParam));
+        if (!(0, exports.areValidSerializedLucidCardPanelTabs)(serializedTabs)) {
+            return undefined;
+        }
+        const result = deserializeLucidCardPanelTabs(serializedTabs);
+        return result;
+    };
+    return wrappedCallback;
+}
+exports.deserializeTabsCallback = deserializeTabsCallback;

package/core/cardintegration/lucidcardintegration.d.ts

@@ -1,4 +1,5 @@
 import { CollectionProxy } from '../../data/collectionproxy';
+import { DataItemProxy } from '../../data/dataitemproxy';
 import { DataSourceProxy } from '../../data/datasourceproxy';
 import { TextStyle } from '../../document/text/textstyle';
 import { EditorClient } from '../../editorclient';
@@ -9,6 +10,7 @@ import { ImportCardFromPastedLinkCallback } from '../importcardfrompastedlink/im
 import { DependenciesForItems, ExtensionCardFieldDefinition, ExtensionFieldConfiguration, ImportResult } from '../sharedcardintegration/cardintegrationdefinitions';
 import { CardIntegrationAutoSyncConfig } from './cardintegrationautosyncconfig';
 import { CardIntegrationConfig } from './cardintegrationconfig';
+import { AdditionalPanelTabsCallback } from './cardpaneltabs/tabs';
 import { DependencyMappingPhrasesType } from './dependencymappingphrases';
 import { LucidCardIntegrationCustomImportModal } from './lucidcardintegrationcustomimportmodal';
 import { LucidCardIntegrationStandardImportModal } from './lucidcardintegrationstandardimportmodal';
@@ -156,7 +158,13 @@ export declare abstract class LucidCardIntegration {
      */
     importFromSerializedFields?: (data: SerializedFields[]) => Promise<ImportCardFromDetails>;
     /**
-     * @experimental When defined, allows the extension to make cards that the user can't edit view-only.
+     * @experimental If specified, allows the extension to check whether the user can edit the given items.
+     * Returns a Map with per-item permission results, keyed by item primary key.
      */
-    canEditItems?: (editedKey: string, dependencyKey: string | undefined) => Promise<UserItemEditPermissions>;
+    canEditItems?: (items: DataItemProxy[]) => Promise<Map<string, UserItemEditPermissions>>;
+    /**
+     * @experimental If specified, allows for cards to display additional details,
+     * via tabs that are configured by the extension and displayed in the card details panel.
+     */
+    getAdditionalPanelTabsForCard?: AdditionalPanelTabsCallback;
 }

package/core/cardintegration/lucidcardintegrationregistry.js

@@ -11,6 +11,7 @@ const importcardfromdetails_1 = require("../importcardfromdetails/importcardfrom
 const cardintegrationdefinitions_1 = require("../sharedcardintegration/cardintegrationdefinitions");
 const cardintegrationautosyncconfig_1 = require("./cardintegrationautosyncconfig");
 const cardintegrationconfig_1 = require("./cardintegrationconfig");
+const tabs_1 = require("./cardpaneltabs/tabs");
 const lucidcardintegrationcustomimportmodal_1 = require("./lucidcardintegrationcustomimportmodal");
 const useritemeditpermissions_1 = require("./useritemeditpermissions");
 class LucidCardIntegrationRegistry {
@@ -258,6 +259,14 @@ class LucidCardIntegrationRegistry {
             const dataSource = new datasourceproxy_1.DataSourceProxy(param['d'], client);
             return (0, cardintegrationconfig_1.serializeCardIntegrationConfig)(await cardIntegration.getDefaultConfig(dataSource));
         });
+        let getFieldsToEditActionName = undefined;
+        const getFieldsToEdit = cardIntegration.fieldConfiguration.getFieldsToEdit;
+        if (getFieldsToEdit) {
+            getFieldsToEditActionName = LucidCardIntegrationRegistry.nextHookName();
+            client.registerAction(getFieldsToEditActionName, async ({ 'f': fieldId }) => {
+                return (0, cardintegrationdefinitions_1.serializeExtensionCardFieldsGroupArray)(await getFieldsToEdit(fieldId));
+            });
+        }
         let showIntroActionName = undefined;
         if (cardIntegration.showIntro) {
             showIntroActionName = LucidCardIntegrationRegistry.nextHookName();
@@ -278,6 +287,7 @@ class LucidCardIntegrationRegistry {
                     ? [...cardIntegration.fieldConfiguration.fieldValueSearchCallbacks.entries()]
                     : undefined,
                 'dsc': cardIntegration.fieldConfiguration.defaultSearchCallback,
+                'gfte': getFieldsToEditActionName,
             },
             'subn': cardIntegration.searchUserByName,
             'usc': cardIntegration.userSearchCallback,
@@ -455,6 +465,10 @@ class LucidCardIntegrationRegistry {
         }
         this.registerDependencyMapping(client, cardIntegration, serialized);
         this.registerImportCardFromPastedLinkHandler(client, cardIntegration, serialized);
+        if (cardIntegration.getAdditionalPanelTabsForCard) {
+            const actionName = LucidCardIntegrationRegistry.nextHookName();
+            (0, tabs_1.registerGetAdditionalPanelTabsForCardCallback)(client, cardIntegration.getAdditionalPanelTabsForCard, serialized, actionName);
+        }
         if (cardIntegration.importFromSerializedFields) {
             const importFromSerializedFields = cardIntegration.importFromSerializedFields;
             serialized['ifs'] = LucidCardIntegrationRegistry.nextHookName();
@@ -465,10 +479,12 @@ class LucidCardIntegrationRegistry {
         }
         if (cardIntegration.canEditItems) {
             const canEditItemsActionName = LucidCardIntegrationRegistry.nextHookName();
+            const canEditItems = cardIntegration.canEditItems;
             serialized['cei'] = canEditItemsActionName;
-            client.registerAction(canEditItemsActionName, async ({ 'ek': editedKey, 'dk': dependencyKey }) => {
-                const result = await cardIntegration.canEditItems(editedKey, dependencyKey);
-                return (0, useritemeditpermissions_1.serializeUserItemEditPermissions)(result);
+            client.registerAction(canEditItemsActionName, async ({ i }) => {
+                const dataItemProxies = i.map((item) => new dataitemproxy_1.DataItemProxy(item['pk'], new collectionproxy_1.CollectionProxy(item['cid'], client), client));
+                const result = await canEditItems(dataItemProxies);
+                return (0, useritemeditpermissions_1.serializeUserItemEditPermissionsMap)(result);
             });
         }
         client.sendCommand("aci" /* CommandName.AddCardIntegration */, serialized);

package/core/cardintegration/useritemeditpermissions.d.ts

@@ -6,7 +6,7 @@ export interface UserItemEditPermissions {
     hasPermission: boolean;
     constraints: {
         fieldName: string;
-        constraints?: SerializedFieldConstraint[];
+        constraints: SerializedFieldConstraint[];
     }[];
 }
 export declare class UserCanEditItem implements UserItemEditPermissions {
@@ -17,10 +17,13 @@ export declare class UserCannotEditItem implements UserItemEditPermissions {
     readonly hasPermission = false;
     constraints: never[];
 }
-export declare function serializeUserItemEditPermissions(result: UserItemEditPermissions): {
-    hp: boolean;
-    c: {
-        fn: string;
-        cs: SerializedFieldConstraint[] | undefined;
+export interface SerializedUserItemEditPermissions {
+    'hp': boolean;
+    'c': {
+        'fn': string;
+        'cs': SerializedFieldConstraint[];
     }[];
-};
+}
+export declare function serializeUserItemEditPermissionsMap(map: Map<string, UserItemEditPermissions>): Record<string, SerializedUserItemEditPermissions>;
+export declare function deserializeUserItemEditPermissionsRecord(serializedMap: Record<string, SerializedUserItemEditPermissions>): Map<string, UserItemEditPermissions>;
+export declare function isValidSerializedUserItemEditPermissionsRecord(value: unknown): value is Record<string, SerializedUserItemEditPermissions>;

package/core/cardintegration/useritemeditpermissions.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeUserItemEditPermissions = exports.UserCannotEditItem = exports.UserCanEditItem = void 0;
+exports.isValidSerializedUserItemEditPermissionsRecord = exports.deserializeUserItemEditPermissionsRecord = exports.serializeUserItemEditPermissionsMap = exports.UserCannotEditItem = exports.UserCanEditItem = void 0;
+const checks_1 = require("../checks");
+const serializedfielddefinition_1 = require("../data/serializedfield/serializedfielddefinition");
+const validators_1 = require("../validators/validators");
 class UserCanEditItem {
     constructor() {
         this.hasPermission = true;
@@ -15,6 +18,13 @@ class UserCannotEditItem {
     }
 }
 exports.UserCannotEditItem = UserCannotEditItem;
+const isSerializedUserItemEditPermissions = (0, validators_1.objectValidator)({
+    'hp': checks_1.isBoolean,
+    'c': (0, validators_1.arrayValidator)((0, validators_1.objectValidator)({
+        'fn': checks_1.isString,
+        'cs': (0, validators_1.arrayValidator)(serializedfielddefinition_1.isSerializedFieldConstraint),
+    })),
+});
 function serializeUserItemEditPermissions(result) {
     return {
         'hp': result.hasPermission,
@@ -24,4 +34,32 @@ function serializeUserItemEditPermissions(result) {
         })),
     };
 }
-exports.serializeUserItemEditPermissions = serializeUserItemEditPermissions;
+function deserializeUserItemEditPermissions(serialized) {
+    return {
+        hasPermission: serialized['hp'],
+        constraints: serialized['c'].map((c) => ({
+            fieldName: c['fn'],
+            constraints: c['cs'],
+        })),
+    };
+}
+function serializeUserItemEditPermissionsMap(map) {
+    const serializedMap = {};
+    for (const [primaryKey, permissions] of map) {
+        serializedMap[primaryKey] = serializeUserItemEditPermissions(permissions);
+    }
+    return serializedMap;
+}
+exports.serializeUserItemEditPermissionsMap = serializeUserItemEditPermissionsMap;
+function deserializeUserItemEditPermissionsRecord(serializedMap) {
+    const map = new Map();
+    for (const [primaryKey, serializedPermissions] of Object.entries(serializedMap)) {
+        map.set(primaryKey, deserializeUserItemEditPermissions(serializedPermissions));
+    }
+    return map;
+}
+exports.deserializeUserItemEditPermissionsRecord = deserializeUserItemEditPermissionsRecord;
+function isValidSerializedUserItemEditPermissionsRecord(value) {
+    return (0, checks_1.isRecord)(isSerializedUserItemEditPermissions)(value);
+}
+exports.isValidSerializedUserItemEditPermissionsRecord = isValidSerializedUserItemEditPermissionsRecord;

package/core/enum.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+export declare function getEnumValues<T extends object>(enumObj: T): keyof T extends never ? [] : T[keyof T][];
+/**
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+export declare function getEnumKeys<T extends object>(enumObj: T): (keyof T)[];
+/**
+ * Returns all real entries of enum. That is, removes the reverse-map entries that TS adds
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+export declare function getRealEnumEntries<T extends object>(enumObj: T): [keyof T, T[keyof T]][];
+/**
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+export declare function isEnumValue<T extends object>(value: any, enumObj: T): value is T[keyof T];
+/**
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+export declare function asEnumValue<T extends object>(value: unknown, enumObj: T): T[keyof T] | undefined;

package/core/enum.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asEnumValue = exports.isEnumValue = exports.getRealEnumEntries = exports.getEnumKeys = exports.getEnumValues = void 0;
+/**
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+function getEnumValues(enumObj) {
+    return getRealEnumEntries(enumObj).map((e) => e[1]);
+}
+exports.getEnumValues = getEnumValues;
+/**
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+function getEnumKeys(enumObj) {
+    return getRealEnumEntries(enumObj).map((e) => e[0]);
+}
+exports.getEnumKeys = getEnumKeys;
+/**
+ * Returns all real entries of enum. That is, removes the reverse-map entries that TS adds
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+function getRealEnumEntries(enumObj) {
+    return Object.keys(enumObj)
+        .map((key) => [key, enumObj[key]])
+        .filter(([key, value]) => value === key || enumObj[value] != key || typeof value == 'number');
+}
+exports.getRealEnumEntries = getRealEnumEntries;
+/**
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+function isEnumValue(value, enumObj) {
+    return getEnumValues(enumObj).includes(value);
+}
+exports.isEnumValue = isEnumValue;
+/**
+ * Note, this will NOT work for const enums, as const enums are compiled out!!
+ * This works because as of TS 2.5 enums can't have number keys.
+ */
+function asEnumValue(value, enumObj) {
+    return isEnumValue(value, enumObj) ? value : undefined;
+}
+exports.asEnumValue = asEnumValue;

package/core/identity.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Adapted from https://google.github.io/closure-library/api/goog.functions.html#identity
+ *
+ * A simple function that returns the first argument of whatever is passed
+ * into it.
+ * @param opt_returnValue The single value that will be returned.
+ * @param var_args Optional trailing arguments. These are ignored.
+ * @return The first argument passed in, or undefined if nothing was passed.
+ * @template T
+ */
+export declare const identity: <T>(opt_returnValue?: T | undefined, ...var_args: any[]) => T;

package/core/identity.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identity = void 0;
+/**
+ * Adapted from https://google.github.io/closure-library/api/goog.functions.html#identity
+ *
+ * A simple function that returns the first argument of whatever is passed
+ * into it.
+ * @param opt_returnValue The single value that will be returned.
+ * @param var_args Optional trailing arguments. These are ignored.
+ * @return The first argument passed in, or undefined if nothing was passed.
+ * @template T
+ */
+const identity = function (opt_returnValue, ...var_args) {
+    // This non-null assertion is needed to maintain the behavior inherited from  the closure library implementation
+    // (specifically, the fact that library has a JS implementation which means we don't quite have the same types to
+    // line up).
+    return opt_returnValue;
+};
+exports.identity = identity;