lucid-extension-sdk 0.0.156 → 0.0.158

package/commandtypes.d.ts

@@ -120,6 +120,7 @@ export declare const enum CommandName {
     UnhookSelection = "us",
     UnhookTextEdit = "ute",
     WithMutex = "wm",
+    WithSilentActions = "wsa",
     ZOrder = "z"
 }
 /** @ignore */
@@ -530,6 +531,10 @@ export declare type CommandArgs = {
         query: WithMutexQuery;
         result: WithMutexResult;
     };
+    [CommandName.WithSilentActions]: {
+        query: WithSilentActionsQuery;
+        result: WithSilentActionsResult;
+    };
     [CommandName.ZOrder]: {
         query: ZOrderQuery;
         result: ZOrderResult;
@@ -1294,6 +1299,11 @@ export declare type WithMutexQuery = {
 };
 /** Resolves true if operation succeeded, or false if the mutex was held by someone else */
 export declare type WithMutexResult = Promise<boolean>;
+export declare type WithSilentActionsQuery = {
+    /** Name of the synchronous action to run with undo/redo history suppressed */
+    'a': string;
+};
+export declare type WithSilentActionsResult = void;
 export declare enum ZOrderOperation {
     UP = 1,
     TOP = 2,

package/commandtypes.js

@@ -100,6 +100,7 @@ exports.commandTitles = new Map([
     ["us" /* CommandName.UnhookSelection */, 'UnhookSelection'],
     ["ute" /* CommandName.UnhookTextEdit */, 'UnhookTextEdit'],
     ["wm" /* CommandName.WithMutex */, 'WithMutex'],
+    ["wsa" /* CommandName.WithSilentActions */, 'WithSilentActions'],
     ["z" /* CommandName.ZOrder */, 'ZOrder'],
 ]);
 var GetItemsAtSearchType;

package/core/data/datasource/datasourceutils.d.ts

@@ -5,10 +5,19 @@ import { UpstreamUpdateType } from './upstreamupdatetype';
 /** @ignore */
 export declare function alphabetize(n: number): string;
 /** @ignore */
+export declare function normalizeName(name: string): string;
+/** @ignore */
+export declare function makeNameReadablyUnique(originalName: string, usedNamesNormalized: Set<string>, transform?: typeof normalizeName): string;
+/** @ignore */
 export declare const MetadataPK = "__PK__";
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
-export declare function makeSerializedImportedCollection(id: string, hash: string, name: string, rawSchema: string[], data: SerializedFields[], metadata?: {
+export declare function makeSerializedImportedCollection(name: string, rawFieldNames: string[], data: SerializedFields[], upstreamConfig: {
+    [key: string]: any;
+}, metadata?: {
     [key: string]: SerializedFields[];
+}, schemaFromData?: {
+    headerRow: number;
+    primaryKey: string[];
 }): SerializedImportedCollection;
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 export declare function makeSerializedImportedDataSource(id: string, name: string, collections: SerializedImportedCollection[]): {

package/core/data/datasource/datasourceutils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSerializedImportedDataSource = exports.makeSerializedImportedCollection = exports.MetadataPK = exports.alphabetize = void 0;
+exports.makeSerializedImportedDataSource = exports.makeSerializedImportedCollection = exports.MetadataPK = exports.makeNameReadablyUnique = exports.normalizeName = exports.alphabetize = void 0;
+const checks_1 = require("../../checks");
 const scalarfieldtype_1 = require("../fieldtypedefinition/scalarfieldtype");
 const alphabet_1 = require("./alphabet");
 const datasourcetype_1 = require("./datasourcetype");
@@ -34,23 +35,84 @@ exports.alphabetize = alphabetize;
 function normalizeName(name) {
     return name.trim().toLowerCase();
 }
+exports.normalizeName = normalizeName;
+const appendedNumberRegex = /(.*) \(([0-9]+)\)$/;
+/** @ignore */
+function makeNameReadablyUnique(originalName, usedNamesNormalized, transform = normalizeName) {
+    if (!usedNamesNormalized.has(transform(originalName))) {
+        return originalName;
+    }
+    const match = appendedNumberRegex.exec(originalName);
+    let count = 1;
+    if (match && (0, checks_1.isString)(match[1]) && (0, checks_1.isString)(match[2])) {
+        originalName = match[1];
+        count = Number(match[2]) + 1;
+    }
+    let newName = originalName;
+    do {
+        newName = originalName + ` (${count})`;
+        count++;
+    } while (usedNamesNormalized.has(transform(newName)));
+    return newName;
+}
+exports.makeNameReadablyUnique = makeNameReadablyUnique;
 /** @ignore */
 exports.MetadataPK = '__PK__';
 /** @ignore */
-function makeSchema(schemaFields) {
+function makePrimaryCollectionSchema(rawSchemaFields, data, schemaFromData) {
+    var _a, _b;
+    const headerRow = (_a = schemaFromData === null || schemaFromData === void 0 ? void 0 : schemaFromData.headerRow) !== null && _a !== void 0 ? _a : -1;
+    const headerRowData = headerRow >= 0 ? data[headerRow] : undefined;
+    const headerRowAsStringArray = headerRowData &&
+        rawSchemaFields.map((rawSchemaField, index) => {
+            var _a;
+            const headerRowDataAsString = `${(_a = headerRowData[rawSchemaField]) !== null && _a !== void 0 ? _a : ''}`;
+            return headerRowDataAsString.trim() === '' ? alphabetize(index) : headerRowDataAsString;
+        });
+    const schemaFields = headerRowAsStringArray !== null && headerRowAsStringArray !== void 0 ? headerRowAsStringArray : rawSchemaFields;
     const fields = [];
     const oldToNewFields = new Map();
     const usedFieldsNormalized = new Set([normalizeName(exports.MetadataPK)]);
     schemaFields.forEach((field, index) => {
-        // don't add duplicates
-        if (!usedFieldsNormalized.has(normalizeName(field))) {
-            usedFieldsNormalized.add(normalizeName(field));
-            // for now we're changing all schema to the alphabet until preview data can be skipped
-            fields.push({ 'Name': alphabetize(index), 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.ANY });
-            oldToNewFields.set(field, alphabetize(index));
+        const finalFieldName = makeNameReadablyUnique(field, usedFieldsNormalized);
+        usedFieldsNormalized.add(normalizeName(finalFieldName));
+        fields.push({ 'Name': finalFieldName, 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.ANY });
+        oldToNewFields.set(rawSchemaFields[index], finalFieldName);
+    });
+    const oldPrimaryKeys = (_b = schemaFromData === null || schemaFromData === void 0 ? void 0 : schemaFromData.primaryKey) !== null && _b !== void 0 ? _b : [];
+    const translatedPrimaryKeys = oldPrimaryKeys
+        .map((oldPrimaryKey) => oldToNewFields.get(oldPrimaryKey))
+        .filter(checks_1.isDefAndNotNull); // There should be no untranslatable primary keys, but we need to satisfy the type system
+    return {
+        sheetSchema: {
+            'Fields': fields,
+            'PrimaryKey': translatedPrimaryKeys,
+        },
+        oldToNewFields,
+    };
+}
+function getPrimaryKeysForData(oldToNewFields, data, schemaFromData) {
+    if (!schemaFromData || schemaFromData.primaryKey.length === 0) {
+        return data.map((row, index) => `${index + 1}`);
+    }
+    const primaryKey = schemaFromData.primaryKey;
+    const primaryKeyInNewFields = primaryKey.map((oldField) => { var _a; return (_a = oldToNewFields.get(oldField)) !== null && _a !== void 0 ? _a : oldField; });
+    // For reasons I have forgotten, the actual primary key order is determined by the alphabetized name order.
+    const sortedPrimaryKeyInNewFields = primaryKeyInNewFields.slice().sort();
+    const sortedPrimaryKey = sortedPrimaryKeyInNewFields.map((newField) => primaryKey[primaryKeyInNewFields.indexOf(newField)]);
+    const usedNames = new Set();
+    return data.map((serializedField) => {
+        const primaryKeyValues = sortedPrimaryKey.map((key) => serializedField[key]);
+        const compositeValue = JSON.stringify(primaryKeyValues);
+        const nameWithoutContext = compositeValue.slice(1, compositeValue.length - 1);
+        let name = nameWithoutContext;
+        let dupCount = -1;
+        while (usedNames.has(name)) {
+            name = `${nameWithoutContext},${++dupCount}`;
         }
+        usedNames.add(name);
+        return name;
     });
-    return { sheetSchema: { 'Fields': fields, 'PrimaryKey': [] }, oldToNewFields };
 }
 /** @ignore */
 function makeMetadataCollection(metadataType, sheetName, dataItems, sheetSchema) {
@@ -61,11 +123,15 @@ function makeMetadataCollection(metadataType, sheetName, dataItems, sheetSchema)
     };
 }
 /** @ignore */
-function makeItemOrderCollection(sheetLength, sheetName) {
+function makeItemOrderCollection(primaryKeys, sheetName, headerRow) {
     const itemOrderItems = {};
-    for (let i = 1; i <= sheetLength; ++i) {
-        const rowIndex = i;
-        itemOrderItems[`${rowIndex}`] = { 'Key': `${rowIndex}`, 'Order': rowIndex };
+    let rowIndex = 0;
+    for (let i = 0; i < primaryKeys.length; i++) {
+        const primaryKey = primaryKeys[i];
+        if (i !== headerRow) {
+            rowIndex++;
+            itemOrderItems[`${rowIndex}`] = { 'Key': `${primaryKey}`, 'Order': rowIndex };
+        }
     }
     const itemOrderSchema = {
         'Fields': [
@@ -77,52 +143,70 @@ function makeItemOrderCollection(sheetLength, sheetName) {
     return makeMetadataCollection('ItemOrder', sheetName, itemOrderItems, itemOrderSchema);
 }
 /** @ignore */
-function makeSerializedItems(rawItems, oldToNewFields, isMetadata = false) {
+function makeHeaderrowMetadataCollection(headerRowPrimaryKey, headerRowData, oldToNewFields, sheetName, schema) {
+    const dataItem = {};
+    for (const [key, field] of Object.entries(headerRowData)) {
+        const newKey = oldToNewFields.get(key);
+        if (newKey) {
+            dataItem[newKey] = field;
+        }
+    }
+    const itemOrderItems = {
+        [headerRowPrimaryKey]: dataItem,
+    };
+    return makeMetadataCollection('HeaderRowMetadata', sheetName, itemOrderItems, schema);
+}
+/** @ignore */
+function makeSerializedItems(primaryKeys, rawItems, oldToNewFields, headerRow, isMetadata = false) {
     const serializedItems = {};
     rawItems.forEach((rawItem, rowIndex) => {
-        const dataItem = {};
-        for (const [key, field] of Object.entries(rawItem)) {
-            const newKey = oldToNewFields.get(key);
-            if (newKey) {
-                dataItem[newKey] = field;
+        if (isMetadata || rowIndex !== headerRow) {
+            const dataItem = {};
+            for (const [key, field] of Object.entries(rawItem)) {
+                const newKey = oldToNewFields.get(key);
+                if (newKey) {
+                    dataItem[newKey] = field;
+                }
+            }
+            const primaryKey = primaryKeys[rowIndex];
+            if (isMetadata && Object.keys(dataItem).length > 0) {
+                const metadataPrimaryKey = `${primaryKey}`;
+                dataItem[exports.MetadataPK] = metadataPrimaryKey;
+                serializedItems[`${JSON.stringify(metadataPrimaryKey)}`] = dataItem;
+            }
+            else if (!isMetadata) {
+                serializedItems[primaryKey] = dataItem;
             }
-        }
-        const primaryKey = rowIndex + 1;
-        if (isMetadata && Object.keys(dataItem).length > 0) {
-            dataItem[exports.MetadataPK] = `${primaryKey}`;
-            serializedItems[`"${primaryKey}"`] = dataItem;
-        }
-        else if (!isMetadata) {
-            serializedItems[primaryKey] = dataItem;
         }
     });
     return serializedItems;
 }
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
-function makeSerializedImportedCollection(id, hash, name, rawSchema, data, metadata) {
-    const { sheetSchema, oldToNewFields } = makeSchema(rawSchema);
+function makeSerializedImportedCollection(name, rawFieldNames, data, upstreamConfig, metadata, schemaFromData) {
+    var _a;
+    const { sheetSchema, oldToNewFields } = makePrimaryCollectionSchema(rawFieldNames, data, schemaFromData);
+    const primaryKeys = getPrimaryKeysForData(oldToNewFields, data, schemaFromData);
+    const headerRow = (_a = schemaFromData === null || schemaFromData === void 0 ? void 0 : schemaFromData.headerRow) !== null && _a !== void 0 ? _a : -1;
     const metadataCollections = {};
-    const itemOrderCollection = makeItemOrderCollection(data.length, name);
-    metadataCollections['ItemOrder'] = itemOrderCollection;
+    metadataCollections['ItemOrder'] = makeItemOrderCollection(primaryKeys, name, headerRow);
+    if (headerRow > -1 && headerRow < data.length) {
+        const headerRowData = data[headerRow];
+        const headerRowPrimaryKey = primaryKeys[headerRow];
+        metadataCollections['HeaderRowMetadata'] = makeHeaderrowMetadataCollection(headerRowPrimaryKey, headerRowData, oldToNewFields, name, sheetSchema);
+    }
     if (metadata) {
         const metadataFields = [{ 'Name': exports.MetadataPK, 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.STRING }];
         sheetSchema['Fields'].forEach((field) => metadataFields.push({ 'Name': field['Name'], 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.STRING }));
         const metadataSchema = { 'Fields': metadataFields, 'PrimaryKey': [exports.MetadataPK] };
         for (const [type, data] of Object.entries(metadata)) {
-            metadataCollections[type] = makeMetadataCollection(type, name, makeSerializedItems(data, oldToNewFields, true), metadataSchema);
+            metadataCollections[type] = makeMetadataCollection(type, name, makeSerializedItems(primaryKeys, data, oldToNewFields, headerRow, true), metadataSchema);
         }
     }
     return {
         'Name': name,
         'Schema': sheetSchema,
-        'Items': makeSerializedItems(data, oldToNewFields),
-        'UpstreamConfig': {
-            'properties': {
-                'UpstreamType': upstreamupdatetype_1.UpstreamUpdateType.EVENTPULL,
-                'sheetId': id,
-                'hash': hash,
-            },
-        },
+        'Items': makeSerializedItems(primaryKeys, data, oldToNewFields, headerRow),
+        'UpstreamConfig': upstreamConfig,
         'Metadata': metadataCollections,
     };
 }

package/core/data/datasource/metadatatypes.d.ts

@@ -4,5 +4,6 @@ export declare enum MetadataTypes {
     FillColor = "FillColor",
     TextColor = "TextColor",
     Comment = "Comment",
-    Formula = "Formula"
+    Formula = "Formula",
+    HeaderRowMetadata = "HeaderRowMetadata"
 }

package/core/data/datasource/metadatatypes.js

@@ -11,4 +11,5 @@ var MetadataTypes;
     MetadataTypes["TextColor"] = "TextColor";
     MetadataTypes["Comment"] = "Comment";
     MetadataTypes["Formula"] = "Formula";
+    MetadataTypes["HeaderRowMetadata"] = "HeaderRowMetadata";
 })(MetadataTypes = exports.MetadataTypes || (exports.MetadataTypes = {}));

package/editorclient.d.ts

@@ -325,5 +325,12 @@ export declare class EditorClient {
      * @returns A promise resolving to a boolean indicating whether the mutex was successfully locked
      */
     withIntraDocumentMutex(name: string, callback: () => void | Promise<void>): Promise<boolean>;
+    /**
+     * @param callback Callback that will be executed with the user's local undo/redo history suppressed. This is
+     * useful when you want to make changes to a document that will not be erased if the user uses undo or redo,
+     * for example adding shape data onto shapes as a result of a background process that collects data from a
+     * remote API.
+     */
+    withSilentActions(callback: () => void): void;
     constructor();
 }

package/editorclient.js

@@ -545,7 +545,28 @@ class EditorClient {
             return await this.sendCommand("wm" /* CommandName.WithMutex */, { 'n': name, 'a': action });
         }
         finally {
-            this.deleteAction(name);
+            this.deleteAction(action);
+        }
+    }
+    /**
+     * @param callback Callback that will be executed with the user's local undo/redo history suppressed. This is
+     * useful when you want to make changes to a document that will not be erased if the user uses undo or redo,
+     * for example adding shape data onto shapes as a result of a background process that collects data from a
+     * remote API.
+     */
+    withSilentActions(callback) {
+        const action = this.getUniqueActionName();
+        this.registerAction(action, () => {
+            const result = callback();
+            if ((0, checks_1.isPromise)(result)) {
+                throw new Error('withSilentActions cannot be used with an async callback');
+            }
+        });
+        try {
+            this.sendCommand("wsa" /* CommandName.WithSilentActions */, { 'a': action });
+        }
+        finally {
+            this.deleteAction(action);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.156",
+    "version": "0.0.158",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "index.js",
     "types": "index.d.ts",