lucid-extension-sdk 0.0.155 → 0.0.157

package/commandtypes.d.ts

@@ -119,6 +119,8 @@ export declare const enum CommandName {
     UnhookDeleteItems = "udi",
     UnhookSelection = "us",
     UnhookTextEdit = "ute",
+    WithMutex = "wm",
+    WithSilentActions = "wsa",
     ZOrder = "z"
 }
 /** @ignore */
@@ -525,6 +527,14 @@ export declare type CommandArgs = {
         query: UnhookTextEditQuery;
         result: UnhookTextEditResult;
     };
+    [CommandName.WithMutex]: {
+        query: WithMutexQuery;
+        result: WithMutexResult;
+    };
+    [CommandName.WithSilentActions]: {
+        query: WithSilentActionsQuery;
+        result: WithSilentActionsResult;
+    };
     [CommandName.ZOrder]: {
         query: ZOrderQuery;
         result: ZOrderResult;
@@ -1281,6 +1291,19 @@ export declare type UnhookTextEditQuery = {
     'n': string;
 };
 export declare type UnhookTextEditResult = undefined;
+export declare type WithMutexQuery = {
+    /** Name of the intra-document mutex to hold for the duration of this action */
+    'n': string;
+    /** Name of the action to run within the given mutex */
+    'a': string;
+};
+/** 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

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

package/editorclient.d.ts

@@ -315,5 +315,22 @@ export declare class EditorClient {
      * @returns a Promise that resolves to a string if a user enters one, or undefined if they cancel
      */
     prompt(text: string, title?: string): import("./commandtypes").PromptResult;
+    /**
+     * Executes the given callback within a mutex scoped to the current document, extension, and the given name.
+     * If another editor session currently has the given mutex name locked within the same extension package ID
+     * on this same document, this function's returned promise will resolve to false. Otherwise, the mutex will
+     * be locked for the duration of the callback and the returned promise will resolve to true.
+     * @param name Name of the intra-document mutex to attempt to lock
+     * @param callback Code to execute while the mutex is locked, if it is successfully locked
+     * @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

@@ -529,5 +529,45 @@ class EditorClient {
     prompt(text, title) {
         return this.sendCommand("p" /* CommandName.Prompt */, { 't': title, 'b': text });
     }
+    /**
+     * Executes the given callback within a mutex scoped to the current document, extension, and the given name.
+     * If another editor session currently has the given mutex name locked within the same extension package ID
+     * on this same document, this function's returned promise will resolve to false. Otherwise, the mutex will
+     * be locked for the duration of the callback and the returned promise will resolve to true.
+     * @param name Name of the intra-document mutex to attempt to lock
+     * @param callback Code to execute while the mutex is locked, if it is successfully locked
+     * @returns A promise resolving to a boolean indicating whether the mutex was successfully locked
+     */
+    async withIntraDocumentMutex(name, callback) {
+        const action = this.getUniqueActionName();
+        this.registerAction(action, callback);
+        try {
+            return await this.sendCommand("wm" /* CommandName.WithMutex */, { 'n': name, 'a': action });
+        }
+        finally {
+            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);
+        }
+    }
 }
 exports.EditorClient = EditorClient;

package/package.json

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