lucid-extension-sdk 0.0.227 → 0.0.229

package/commandtypes.d.ts

@@ -1103,10 +1103,19 @@ export type GetItemsAtQuery = {
 /** IDs of the items found */
 export type GetItemsAtResult = string[];
 export declare enum GetLLMContextType {
-    /** Get context in a format for LLMs where relationships among connected and contained items is preserved */
+    /** Get context in a format for LLMs where relationships among connected and
+     * contained items are preserved. Expand the scope of the selection to
+     * include blocks contained by the selection as well as lines connecting
+     * items in the selection. */
     Relational = 1,
     /** Get context containing only plain text displayed on the given items, more suitable for embeddings */
-    PlainText = 2
+    PlainText = 2,
+    /** Get context in a format for LLMs where relationships among connected and
+     * contained items are preserved. Do not expand the scope of the selection,
+     * other than to ensure relationships are represented. Text on selected
+     * items will be included, but text on automatically added items will not.
+     * */
+    RelationalWithoutExpansion = 3
 }
 export type GetLLMContextFromItemsQuery = {
     /** Page ID to find closely-related items */

package/commandtypes.js

@@ -137,10 +137,19 @@ var GetItemsAtSearchType;
 })(GetItemsAtSearchType || (exports.GetItemsAtSearchType = GetItemsAtSearchType = {}));
 var GetLLMContextType;
 (function (GetLLMContextType) {
-    /** Get context in a format for LLMs where relationships among connected and contained items is preserved */
+    /** Get context in a format for LLMs where relationships among connected and
+     * contained items are preserved. Expand the scope of the selection to
+     * include blocks contained by the selection as well as lines connecting
+     * items in the selection. */
     GetLLMContextType[GetLLMContextType["Relational"] = 1] = "Relational";
     /** Get context containing only plain text displayed on the given items, more suitable for embeddings */
     GetLLMContextType[GetLLMContextType["PlainText"] = 2] = "PlainText";
+    /** Get context in a format for LLMs where relationships among connected and
+     * contained items are preserved. Do not expand the scope of the selection,
+     * other than to ensure relationships are represented. Text on selected
+     * items will be included, but text on automatically added items will not.
+     * */
+    GetLLMContextType[GetLLMContextType["RelationalWithoutExpansion"] = 3] = "RelationalWithoutExpansion";
 })(GetLLMContextType || (exports.GetLLMContextType = GetLLMContextType = {}));
 function isRawSendXHRResponse(val) {
     return (0, checks_1.isString)(val['url']) && (0, checks_1.isString)(val['t']) && (0, checks_1.isNumber)(val['s']) && (0, checks_1.isObject)(val['h']);

package/data/collectionerrortypes.d.ts

@@ -0,0 +1 @@
+export declare const CollectionUpstreamSchemaStatus = "__CollectionUpstreamSchemaStatus__";

package/data/collectionerrortypes.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionUpstreamSchemaStatus = void 0;
+exports.CollectionUpstreamSchemaStatus = '__CollectionUpstreamSchemaStatus__';

package/dataconnector/datasourceupdatetypes.d.ts

@@ -2,7 +2,7 @@ import { UpstreamPatchType } from '../core/data/datasource/upstreampatchtype';
 import { SerializedFieldTypeDefinition } from '../core/data/fieldtypedefinition/fieldtypedefinition';
 import { SemanticKind } from '../core/data/fieldtypedefinition/semantickind';
 import { FieldConstraintType } from '../core/data/serializedfield/serializedfielddefinition';
-import { SerializedFields } from '../core/data/serializedfield/serializedfields';
+import { SerializedFields, SerializedLucidDictionary } from '../core/data/serializedfield/serializedfields';
 import { SerializedLabelOverrides } from '../core/data/serializedfield/serializedschema';
 import { JsonSerializable } from '../core/jsonserializable';
 import { DataUpdateFilterType } from '../data/dataupdatefiltertype';
@@ -51,6 +51,7 @@ export declare class ItemsPatchInexhaustive {
     items: Map<string, SerializedFields>;
     /** Items to remove from the collection, based on the same primary key algorithm. */
     itemsDeleted?: string[] | undefined;
+    errors?: Map<string, SerializedLucidDictionary> | undefined;
     constructor(
     /**
      * Items to be added or changed in the collection. Mapping from item serialized primary key to
@@ -58,11 +59,12 @@ export declare class ItemsPatchInexhaustive {
      **/
     items: Map<string, SerializedFields>, 
     /** Items to remove from the collection, based on the same primary key algorithm. */
-    itemsDeleted?: string[] | undefined);
+    itemsDeleted?: string[] | undefined, errors?: Map<string, SerializedLucidDictionary> | undefined);
 }
 export declare class ItemsPatchExhaustive {
     items: Map<string, SerializedFields>;
-    constructor(items: Map<string, SerializedFields>);
+    errors?: Map<string, SerializedLucidDictionary> | undefined;
+    constructor(items: Map<string, SerializedFields>, errors?: Map<string, SerializedLucidDictionary> | undefined);
 }
 export type ItemsPatch = {
     /**
@@ -72,12 +74,16 @@ export type ItemsPatch = {
     items: Map<string, SerializedFields>;
     /** Items to remove from the collection, based on the same primary key algorithm. */
     itemsDeleted?: string[];
+    /** Errors found while patching the items */
+    errors?: Map<string, SerializedLucidDictionary>;
 } | ItemsPatchInexhaustive | ItemsPatchExhaustive;
 export type SerializedItemsPatch = {
     'items': Record<string, SerializedFields>;
     'itemsDeleted': string[];
+    'errors'?: Record<string, SerializedLucidDictionary>;
 } | {
     'exhaustiveItems': Record<string, SerializedFields>;
+    'errors'?: Record<string, SerializedLucidDictionary>;
 };
 export declare function serializeItemsPatch(patch: ItemsPatch): SerializedItemsPatch;
 /**
@@ -102,4 +108,28 @@ export interface CollectionPatch {
 /** @ignore */
 export declare function serializeFieldDefinitionForApi(field: FieldDefinition): SerializedFieldDefinitionForApi;
 export declare function serializeCollectionPatch(patch: CollectionPatch): SerializedCollectionPatch;
+/**
+ * For the moment, when the upstream Google Sheet is changed in such a way that the schema has changed, we simply
+ * stop updates from happening. We do need to alert the user that this has happened, though. This is a utility function
+ * for creating the appropriate entry in the errors map so that the user can be alerted that updates have stopped
+ * and what they need to do to fix it.
+ *
+ * The eventual, proposed fix is to allow schemas to have version numbers so that changes to the schema from Google
+ * can simply be folded in to the on-document copies of the data and all following edits.
+ *
+ * @param oldPrimaryKey The primary key stored in the data sync service and which currently is used to interpret
+ * patches.
+ * @param newPrimaryKey The primary key as it has been changed in the real Google Sheets.
+ * @returns The error map entry which alerts the document that this problem has happened.
+ */
+export declare function schemaOutOfSyncStatus(oldPrimaryKey: string[], newPrimaryKey: string[]): [string, SerializedLucidDictionary];
+/**
+ * For the moment, when the upstream Google Sheet is changed in such a way that the schema has changed, we simply
+ * stop updates from happening. We do need to alert the user that this has happened, though. We also need to know when
+ * the updates are happening properly so we can clear the error once the user has resolved the problem. Since the
+ * only way to delete errors is to overwrite them, we simply overwrite the error to be OK on every successful
+ * import.
+ * @returns The error map entry which alerts the document that this problem has been resolved.
+ */
+export declare function schemaOKStatus(): [string, SerializedLucidDictionary];
 export {};

package/dataconnector/datasourceupdatetypes.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeCollectionPatch = exports.serializeFieldDefinitionForApi = exports.serializeItemsPatch = exports.ItemsPatchExhaustive = exports.ItemsPatchInexhaustive = void 0;
+exports.schemaOKStatus = exports.schemaOutOfSyncStatus = exports.serializeCollectionPatch = exports.serializeFieldDefinitionForApi = exports.serializeItemsPatch = exports.ItemsPatchExhaustive = exports.ItemsPatchInexhaustive = void 0;
 const fieldtypedefinition_1 = require("../core/data/fieldtypedefinition/fieldtypedefinition");
 const object_1 = require("../core/object");
+const collectionerrortypes_1 = require("../data/collectionerrortypes");
 class ItemsPatchInexhaustive {
     constructor(
     /**
@@ -11,28 +12,35 @@ class ItemsPatchInexhaustive {
      **/
     items, 
     /** Items to remove from the collection, based on the same primary key algorithm. */
-    itemsDeleted) {
+    itemsDeleted, errors) {
         this.items = items;
         this.itemsDeleted = itemsDeleted;
+        this.errors = errors;
     }
 }
 exports.ItemsPatchInexhaustive = ItemsPatchInexhaustive;
 class ItemsPatchExhaustive {
-    constructor(items) {
+    constructor(items, errors) {
         this.items = items;
+        this.errors = errors;
     }
 }
 exports.ItemsPatchExhaustive = ItemsPatchExhaustive;
+function serializeErrors(errors) {
+    if (!errors) {
+        return undefined;
+    }
+    const serializedErrors = {};
+    errors.forEach((dictionary, key) => (serializedErrors[key] = dictionary));
+    return { 'errors': serializedErrors };
+}
 function serializeItemsPatch(patch) {
     var _a;
     if (patch instanceof ItemsPatchExhaustive) {
-        return { 'exhaustiveItems': (0, object_1.fromEntries)(patch.items.entries()) };
+        return Object.assign({ 'exhaustiveItems': (0, object_1.fromEntries)(patch.items.entries()) }, serializeErrors(patch.errors));
     }
     else {
-        return {
-            'items': (0, object_1.fromEntries)(patch.items.entries()),
-            'itemsDeleted': (_a = patch.itemsDeleted) !== null && _a !== void 0 ? _a : [],
-        };
+        return Object.assign({ 'items': (0, object_1.fromEntries)(patch.items.entries()), 'itemsDeleted': (_a = patch.itemsDeleted) !== null && _a !== void 0 ? _a : [] }, serializeErrors(patch.errors));
     }
 }
 exports.serializeItemsPatch = serializeItemsPatch;
@@ -67,6 +75,54 @@ function serializeCollectionPatch(patch) {
     };
 }
 exports.serializeCollectionPatch = serializeCollectionPatch;
+/**
+ * For the moment, when the upstream Google Sheet is changed in such a way that the schema has changed, we simply
+ * stop updates from happening. We do need to alert the user that this has happened, though. This is a utility function
+ * for creating the appropriate entry in the errors map so that the user can be alerted that updates have stopped
+ * and what they need to do to fix it.
+ *
+ * The eventual, proposed fix is to allow schemas to have version numbers so that changes to the schema from Google
+ * can simply be folded in to the on-document copies of the data and all following edits.
+ *
+ * @param oldPrimaryKey The primary key stored in the data sync service and which currently is used to interpret
+ * patches.
+ * @param newPrimaryKey The primary key as it has been changed in the real Google Sheets.
+ * @returns The error map entry which alerts the document that this problem has happened.
+ */
+function schemaOutOfSyncStatus(oldPrimaryKey, newPrimaryKey) {
+    return [
+        collectionerrortypes_1.CollectionUpstreamSchemaStatus,
+        {
+            'dict': {
+                'status': 'broken',
+                'onDocumentKey': JSON.stringify(oldPrimaryKey),
+                'upstreamKey': JSON.stringify(newPrimaryKey),
+            },
+        },
+    ];
+}
+exports.schemaOutOfSyncStatus = schemaOutOfSyncStatus;
+/**
+ * For the moment, when the upstream Google Sheet is changed in such a way that the schema has changed, we simply
+ * stop updates from happening. We do need to alert the user that this has happened, though. We also need to know when
+ * the updates are happening properly so we can clear the error once the user has resolved the problem. Since the
+ * only way to delete errors is to overwrite them, we simply overwrite the error to be OK on every successful
+ * import.
+ * @returns The error map entry which alerts the document that this problem has been resolved.
+ */
+function schemaOKStatus() {
+    return [
+        collectionerrortypes_1.CollectionUpstreamSchemaStatus,
+        {
+            'dict': {
+                'status': 'ok',
+                'onDocumentKey': null,
+                'upstreamKey': null,
+            },
+        },
+    ];
+}
+exports.schemaOKStatus = schemaOKStatus;
 const assertIsJustRenamed = () => undefined;
 assertIsJustRenamed();
 assertIsJustRenamed();

package/package.json

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