lucid-extension-sdk 0.0.146 → 0.0.148

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

@@ -0,0 +1 @@
+export declare const alphabet: string[];

package/core/data/datasource/alphabet.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alphabet = void 0;
+exports.alphabet = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+];

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

@@ -0,0 +1,26 @@
+import { SerializedFields } from '../serializedfield/serializedfields';
+import { DataSourceType } from './datasourcetype';
+import { SerializedImportedCollection } from './serializedimporteddatasource';
+import { UpstreamUpdateType } from './upstreamupdatetype';
+/** @ignore */
+export declare function alphabetize(n: number): string;
+/** @ignore */
+export declare const MetadataPK = "__PK__";
+/** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
+export declare function makeSerializedImportedCollection(id: string, name: string, rawSchema: string[], data: SerializedFields[], metadata?: {
+    [key: string]: SerializedFields[];
+}): SerializedImportedCollection;
+/** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
+export declare function makeSerializedImportedDataSource(id: string, name: string, collections: SerializedImportedCollection[]): {
+    Properties: {
+        Name: string;
+        UpstreamConfig: {
+            SourceType: DataSourceType;
+            UpdateType: UpstreamUpdateType;
+            SourceConfig: {
+                spreadsheetId: string;
+            };
+        };
+    };
+    Collections: SerializedImportedCollection[];
+};

package/core/data/datasource/datasourceutils.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSerializedImportedDataSource = exports.makeSerializedImportedCollection = exports.MetadataPK = exports.alphabetize = void 0;
+const scalarfieldtype_1 = require("../fieldtypedefinition/scalarfieldtype");
+const alphabet_1 = require("./alphabet");
+const datasourcetype_1 = require("./datasourcetype");
+const upstreamupdatetype_1 = require("./upstreamupdatetype");
+/** @ignore */
+function _alphabetize(n) {
+    if (n == undefined || n < 0) {
+        return '';
+    }
+    else if (n < alphabet_1.alphabet.length) {
+        return alphabet_1.alphabet[n];
+    }
+    else {
+        return alphabetize(Math.floor(n / alphabet_1.alphabet.length) - 1) + alphabetize(n % alphabet_1.alphabet.length);
+    }
+}
+/** @ignore */
+const memoize = new Map();
+/** @ignore */
+function alphabetize(n) {
+    const stored = memoize.get(n);
+    if (stored != null) {
+        return stored;
+    }
+    const value = _alphabetize(n);
+    memoize.set(n, value);
+    return value;
+}
+exports.alphabetize = alphabetize;
+/** @ignore */
+function normalizeName(name) {
+    return name.trim().toLowerCase();
+}
+/** @ignore */
+exports.MetadataPK = '__PK__';
+/** @ignore */
+function makeSchema(schemaFields) {
+    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));
+        }
+    });
+    return { sheetSchema: { 'Fields': fields, 'PrimaryKey': [] }, oldToNewFields };
+}
+/** @ignore */
+function makeMetadataCollection(metadataType, sheetName, dataItems, sheetSchema) {
+    return {
+        'Name': sheetName + '|' + metadataType,
+        'Schema': sheetSchema,
+        'Items': dataItems,
+    };
+}
+/** @ignore */
+function makeItemOrderCollection(sheetLength, sheetName) {
+    const itemOrderItems = {};
+    for (let i = 1; i <= sheetLength; ++i) {
+        const rowIndex = i;
+        itemOrderItems[`${rowIndex}`] = { 'Key': `${rowIndex}`, 'Order': rowIndex };
+    }
+    const itemOrderSchema = {
+        'Fields': [
+            { 'Name': 'Key', 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.STRING },
+            { 'Name': 'Order', 'Type': scalarfieldtype_1.ScalarFieldTypeEnum.NUMBER },
+        ],
+        'PrimaryKey': ['Order'],
+    };
+    return makeMetadataCollection('ItemOrder', sheetName, itemOrderItems, itemOrderSchema);
+}
+/** @ignore */
+function makeSerializedItems(rawItems, oldToNewFields, 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;
+            }
+        }
+        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, name, rawSchema, data, metadata) {
+    const { sheetSchema, oldToNewFields } = makeSchema(rawSchema);
+    const metadataCollections = {};
+    const itemOrderCollection = makeItemOrderCollection(data.length, name);
+    metadataCollections['ItemOrder'] = itemOrderCollection;
+    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);
+        }
+    }
+    return {
+        'Name': name,
+        'Schema': sheetSchema,
+        'Items': makeSerializedItems(data, oldToNewFields),
+        'UpstreamConfig': {
+            'properties': {
+                'UpstreamType': upstreamupdatetype_1.UpstreamUpdateType.EVENTPULL,
+                'sheetId': id,
+            },
+        },
+        'Metadata': metadataCollections,
+    };
+}
+exports.makeSerializedImportedCollection = makeSerializedImportedCollection;
+/** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
+function makeSerializedImportedDataSource(id, name, collections) {
+    return {
+        'Properties': {
+            'Name': name,
+            'UpstreamConfig': {
+                'SourceType': datasourcetype_1.DataSourceType.DataService,
+                'UpdateType': upstreamupdatetype_1.UpstreamUpdateType.EVENTPULL,
+                'SourceConfig': { 'spreadsheetId': id },
+            },
+        },
+        'Collections': collections,
+    };
+}
+exports.makeSerializedImportedDataSource = makeSerializedImportedDataSource;

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

@@ -17,7 +17,7 @@ export declare const isSerializedImportedMetadataCollection: (subject: unknown)
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 export interface SerializedImportedCollection {
     'Name': string;
-    'Id': string;
+    'Id'?: string;
     'Schema': SerializedSchema;
     'Items': SerializedDataItems;
     'UpstreamConfig': {
@@ -30,7 +30,6 @@ export interface SerializedImportedCollection {
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 export declare const isSerializedImportedCollection: (subject: unknown) => subject is import("../../guards").DestructureGuardedTypeObj<{
     Name: typeof isString;
-    Id: typeof isString;
     Schema: typeof isSerializedSchema;
     Items: typeof isSerializedDataItems;
     UpstreamConfig: typeof isObject;
@@ -58,7 +57,6 @@ export declare const isSerializedImportedDataSource: (subject: unknown) => subje
     }>;
     Collections: (val: unknown) => val is import("../../guards").DestructureGuardedTypeObj<{
         Name: typeof isString;
-        Id: typeof isString;
         Schema: typeof isSerializedSchema;
         Items: typeof isSerializedDataItems;
         UpstreamConfig: typeof isObject;

package/core/data/datasource/serializedimporteddatasource.js

@@ -15,7 +15,6 @@ exports.isSerializedImportedMetadataCollection = (0, validators_1.strictObjectVa
 /** @ignore until spreadsheet integration is ready for launch (CHART-51946) */
 exports.isSerializedImportedCollection = (0, validators_1.strictObjectValidator)({
     'Name': checks_1.isString,
-    'Id': checks_1.isString,
     'Schema': serializedschema_1.isSerializedSchema,
     'Items': serializeddataitems_1.isSerializedDataItems,
     'UpstreamConfig': checks_1.isObject,

package/core/lucidproduct.d.ts

@@ -3,5 +3,6 @@
  */
 export declare enum LucidProduct {
     Chart = "chart",
-    Spark = "spark"
+    Spark = "spark",
+    TeamSpaces = "teamspaces"
 }

package/core/lucidproduct.js

@@ -8,4 +8,5 @@ var LucidProduct;
 (function (LucidProduct) {
     LucidProduct["Chart"] = "chart";
     LucidProduct["Spark"] = "spark";
+    LucidProduct["TeamSpaces"] = "teamspaces";
 })(LucidProduct = exports.LucidProduct || (exports.LucidProduct = {}));

package/index.d.ts

@@ -7,6 +7,7 @@ export * from './core/cardintegration/lucidcardintegration';
 export * from './core/cardintegration/lucidcardintegrationregistry';
 export * from './core/checks';
 export * from './core/data/datasource/datasourcetype';
+export * from './core/data/datasource/datasourceutils';
 export * from './core/data/datasource/metadatatypes';
 export * from './core/data/datasource/serializeddatasourceproperties';
 export * from './core/data/datasource/serializedimporteddatasource';

package/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./core/cardintegration/lucidcardintegration"), exports);
 __exportStar(require("./core/cardintegration/lucidcardintegrationregistry"), exports);
 __exportStar(require("./core/checks"), exports);
 __exportStar(require("./core/data/datasource/datasourcetype"), exports);
+__exportStar(require("./core/data/datasource/datasourceutils"), exports);
 __exportStar(require("./core/data/datasource/metadatatypes"), exports);
 __exportStar(require("./core/data/datasource/serializeddatasourceproperties"), exports);
 __exportStar(require("./core/data/datasource/serializedimporteddatasource"), exports);

package/package.json

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