lucid-extension-sdk 0.0.441 → 0.0.442

package/commandtypes.d.ts

@@ -784,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 */
@@ -933,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 */

package/core/cardintegration/cardfielddisplaysettings.d.ts

@@ -86,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

@@ -93,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/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

@@ -10,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';
@@ -161,4 +162,9 @@ export declare abstract class LucidCardIntegration {
      * Returns a Map with per-item permission results, keyed by item primary key.
      */
     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();

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 {
@@ -21,7 +21,7 @@ export interface SerializedUserItemEditPermissions {
     'hp': boolean;
     'c': {
         'fn': string;
-        'cs': SerializedFieldConstraint[] | undefined;
+        'cs': SerializedFieldConstraint[];
     }[];
 }
 export declare function serializeUserItemEditPermissionsMap(map: Map<string, UserItemEditPermissions>): Record<string, SerializedUserItemEditPermissions>;

package/core/cardintegration/useritemeditpermissions.js

@@ -22,7 +22,7 @@ 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.option)((0, validators_1.arrayValidator)(serializedfielddefinition_1.isSerializedFieldConstraint)),
+        'cs': (0, validators_1.arrayValidator)(serializedfielddefinition_1.isSerializedFieldConstraint),
     })),
 });
 function serializeUserItemEditPermissions(result) {

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;

package/core/iterable.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Retrieves and consumes the first value from an iterator.
+ * Useful because most iterators don't track their return type, because it is usually undefined, but the default is any.
+ */
+export declare function consumeFirstValue<N>(iterator: Iterator<N, undefined | void>): N | undefined;
+/**
+ * Merges multiple generator functions into a single generator that yields all values sequentially.
+ * Each generator function will be called and its values yielded in the order provided.
+ */
+export declare function mergeGenerators<T>(...generatorFunctions: (() => Iterable<T>)[]): () => Generator<T, void, undefined>;
+/**
+ * Zips an object of iterables, shorter iterables will simply repeat the last value.
+ * For example:
+ * {a: [1, 2], b: [1,2,3]} will return [{a: 1, b: 1}, {a: 2, b: 2}, {a: 2, b: 3}]
+ *
+ * Assumes that no iterables are empty
+ */
+export declare function zipHoldShorter<T extends {
+    [key: string]: Iterable<unknown>;
+}>(obj: T): Iterable<{
+    [key in keyof T]-?: T[key] extends Iterable<infer U> ? U : never;
+}>;

package/core/iterable.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipHoldShorter = exports.mergeGenerators = exports.consumeFirstValue = void 0;
+/**
+ * Retrieves and consumes the first value from an iterator.
+ * Useful because most iterators don't track their return type, because it is usually undefined, but the default is any.
+ */
+function consumeFirstValue(iterator) {
+    return iterator.next().value;
+}
+exports.consumeFirstValue = consumeFirstValue;
+/**
+ * Merges multiple generator functions into a single generator that yields all values sequentially.
+ * Each generator function will be called and its values yielded in the order provided.
+ */
+function mergeGenerators(...generatorFunctions) {
+    return function* () {
+        for (const generatorFunction of generatorFunctions) {
+            yield* generatorFunction();
+        }
+    };
+}
+exports.mergeGenerators = mergeGenerators;
+/**
+ * Zips an object of iterables, shorter iterables will simply repeat the last value.
+ * For example:
+ * {a: [1, 2], b: [1,2,3]} will return [{a: 1, b: 1}, {a: 2, b: 2}, {a: 2, b: 3}]
+ *
+ * Assumes that no iterables are empty
+ */
+function* zipHoldShorter(obj) {
+    const unheldKeys = new Set(Object.keys(obj));
+    const iterators = {};
+    for (const key of unheldKeys) {
+        const value = obj[key];
+        //Please note these keys are retrieved from obj directly. So this should never be entered barring some strange edge case.
+        if (value === undefined) {
+            continue;
+        }
+        iterators[key] = value[Symbol.iterator]();
+    }
+    const heldValues = {};
+    let previous = {};
+    while (unheldKeys.size > 0) {
+        const zipped = Object.assign({}, heldValues);
+        for (const key of unheldKeys) {
+            const result = iterators[key].next();
+            if (result.done) {
+                heldValues[key] = previous[key];
+                unheldKeys.delete(key);
+                zipped[key] = heldValues[key];
+            }
+            else {
+                zipped[key] = result.value;
+            }
+        }
+        previous = zipped;
+        if (unheldKeys.size > 0) {
+            yield zipped;
+        }
+    }
+}
+exports.zipHoldShorter = zipHoldShorter;

package/core/map.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A Map that automatically creates values for missing keys using a provided getter function.
+ * Extends the standard Map with automatic value generation on access.
+ */
+export declare class DefaultMap<K, V> extends Map<K, V> {
+    private readonly defaultGetter;
+    get(key: K): V;
+    getIfHas(key: K): V | undefined;
+    constructor(defaultGetter: (key: K) => V, iterable?: Iterable<readonly [K, V]> | null);
+}
+/**
+ * A WeakMap that automatically creates values for missing keys using a default getter function.
+ * Extends the standard WeakMap with automatic value generation on access.
+ */
+export declare class DefaultWeakMap<K extends object, V> extends WeakMap<K, V> {
+    private readonly defaultGetter;
+    get(key: K): V;
+    getIfHas(key: K): V | undefined;
+    constructor(defaultGetter: (key: K) => V);
+}
+export declare function toRecord<K extends string | number, V>(map: ReadonlyMap<K, V>): Partial<Record<K, V>>;
+export declare function toNonPartialRecord<K extends string | number, V>(map: ReadonlyMap<K, V>): Record<K, V>;

package/core/map.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNonPartialRecord = exports.toRecord = exports.DefaultWeakMap = exports.DefaultMap = void 0;
+/**
+ * A Map that automatically creates values for missing keys using a provided getter function.
+ * Extends the standard Map with automatic value generation on access.
+ */
+class DefaultMap extends Map {
+    get(key) {
+        if (!this.has(key)) {
+            this.set(key, this.defaultGetter(key));
+        }
+        return super.get(key);
+    }
+    getIfHas(key) {
+        return super.get(key);
+    }
+    constructor(defaultGetter, iterable) {
+        super(iterable);
+        this.defaultGetter = defaultGetter;
+    }
+}
+exports.DefaultMap = DefaultMap;
+/**
+ * A WeakMap that automatically creates values for missing keys using a default getter function.
+ * Extends the standard WeakMap with automatic value generation on access.
+ */
+class DefaultWeakMap extends WeakMap {
+    get(key) {
+        if (!this.has(key)) {
+            this.set(key, this.defaultGetter(key));
+        }
+        return super.get(key);
+    }
+    getIfHas(key) {
+        return super.get(key);
+    }
+    constructor(defaultGetter) {
+        super();
+        this.defaultGetter = defaultGetter;
+    }
+}
+exports.DefaultWeakMap = DefaultWeakMap;
+function toRecord(map) {
+    return Object.fromEntries(map.entries());
+}
+exports.toRecord = toRecord;
+function toNonPartialRecord(map) {
+    return Object.fromEntries(map.entries());
+}
+exports.toNonPartialRecord = toNonPartialRecord;

package/core/maybepartialrecord.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Note that the intended use of this method is only to handle `Record<string, V>`, not `Record<number, V>`. Using a
+ * number key is not supported here because this utility is meant to only represent records that are both valid
+ * JavaScript and valid JSON (and, number keys are not valid in JSON).
+ */
+export type MaybePartialRecord<K extends string | number, V> = string extends K ? Record<K, V> : Partial<Record<K, V>>;
+/** @see {MaybePartialRecord} */
+export type ReadonlyMaybePartialRecord<K extends string | number, V> = string extends K ? {
+    +readonly [key in K]: V;
+} : {
+    +readonly [key in K]+?: V;
+};

package/core/maybepartialrecord.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });