@sigmacomputing/plugin 1.1.0 → 1.1.1

package/dist/client/initialize.d.ts

@@ -0,0 +1,3 @@
+import { PluginInstance } from '../types';
+export declare function initialize<T = {}>(): PluginInstance<T>;
+//# sourceMappingURL=initialize.d.ts.map

package/dist/client/initialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../src/client/initialize.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,cAAc,EAMf,MAAM,UAAU,CAAC;AAElB,wBAAgB,UAAU,CAAC,CAAC,GAAG,EAAE,KAAK,cAAc,CAAC,CAAC,CAAC,CAqQtD"}

package/dist/client/initialize.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialize = void 0;
+const error_1 = require("../error");
+function initialize() {
+    const pluginConfig = {
+        config: {},
+    };
+    let subscribedInteractions = {};
+    let subscribedWorkbookVars = {};
+    let subscribedUrlParameters = {};
+    const registeredEffects = {};
+    const listeners = {};
+    for (const [key, value] of new URL(document.location.toString()).searchParams.entries())
+        pluginConfig[key] = JSON.parse(value);
+    const listener = (e) => {
+        emit(e.data.type, e.data.result, e.data.error);
+    };
+    window.addEventListener('message', listener, false);
+    window.addEventListener('click', () => execPromise('wb:plugin:focus'));
+    on('wb:plugin:config:update', (config) => {
+        var _a;
+        Object.assign(pluginConfig, config);
+        emit('config', (_a = pluginConfig.config) !== null && _a !== void 0 ? _a : {});
+    });
+    // send initialize event
+    void execPromise('wb:plugin:init', require('../../package.json').version).then(config => {
+        Object.assign(pluginConfig, config);
+        emit('init', pluginConfig);
+        emit('config', pluginConfig.config);
+    });
+    on('wb:plugin:variable:update', (updatedVariables) => {
+        subscribedWorkbookVars = {};
+        Object.assign(subscribedWorkbookVars, updatedVariables);
+    });
+    on('wb:plugin:selection:update', (updatedInteractions) => {
+        subscribedInteractions = {};
+        Object.assign(subscribedInteractions, updatedInteractions);
+    });
+    on('wb:plugin:url-parameter:update', (updatedUrlParameters) => {
+        subscribedUrlParameters = {};
+        Object.assign(subscribedUrlParameters, updatedUrlParameters);
+    });
+    on('wb:plugin:action-effect:invoke', (configId) => {
+        const effect = registeredEffects[configId];
+        if (!effect) {
+            throw new Error(`Unknown action effect with name: ${configId}`);
+        }
+        effect();
+    });
+    function on(event, listener) {
+        listeners[event] = listeners[event] || [];
+        listeners[event].push(listener);
+    }
+    function off(event, listener) {
+        if (listeners[event] == null)
+            return;
+        listeners[event] = listeners[event].filter(a => a !== listener);
+    }
+    function emit(event, ...args) {
+        Object.values(listeners[event] || []).forEach(fn => fn(...args));
+    }
+    function execPromise(event, ...args) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            const callback = (data, error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(data);
+                off(event, callback);
+            };
+            on(event, callback);
+            window.parent.postMessage({ type: event, args, elementId: pluginConfig.id }, (_a = pluginConfig === null || pluginConfig === void 0 ? void 0 : pluginConfig.wbOrigin) !== null && _a !== void 0 ? _a : '*');
+        });
+    }
+    return {
+        get sigmaEnv() {
+            return pluginConfig.sigmaEnv;
+        },
+        get isScreenshot() {
+            return pluginConfig.screenshot;
+        },
+        config: {
+            // @ts-ignore
+            getKey(key) {
+                var _a;
+                return (_a = pluginConfig === null || pluginConfig === void 0 ? void 0 : pluginConfig.config) === null || _a === void 0 ? void 0 : _a[key];
+            },
+            get() {
+                return pluginConfig.config;
+            },
+            set(partialConfig) {
+                void execPromise('wb:plugin:config:update', partialConfig);
+            },
+            setKey(key, value) {
+                void execPromise('wb:plugin:config:update', {
+                    [key]: value,
+                });
+            },
+            subscribe(listener) {
+                on('config', listener);
+                return () => off('config', listener);
+            },
+            getVariable(configId) {
+                (0, error_1.validateConfigId)(configId, 'variable');
+                return subscribedWorkbookVars[configId];
+            },
+            setVariable(configId, ...values) {
+                (0, error_1.validateConfigId)(configId, 'variable');
+                void execPromise('wb:plugin:variable:set', configId, ...values);
+            },
+            getInteraction(configId) {
+                (0, error_1.validateConfigId)(configId, 'interaction');
+                return subscribedInteractions[configId];
+            },
+            setInteraction(configId, elementId, selection) {
+                (0, error_1.validateConfigId)(configId, 'interaction');
+                void execPromise('wb:plugin:selection:set', configId, elementId, selection);
+            },
+            triggerAction(configId) {
+                (0, error_1.validateConfigId)(configId, 'action-trigger');
+                void execPromise('wb:plugin:action-trigger:invoke', configId);
+            },
+            registerEffect(configId, effect) {
+                (0, error_1.validateConfigId)(configId, 'action-effect');
+                registeredEffects[configId] = effect;
+                return () => {
+                    delete registeredEffects[configId];
+                };
+            },
+            configureEditorPanel(options) {
+                void execPromise('wb:plugin:config:inspector', options);
+            },
+            setLoadingState(loadingState) {
+                void execPromise('wb:plugin:config:loading-state', loadingState);
+            },
+            subscribeToWorkbookVariable(configId, callback) {
+                (0, error_1.validateConfigId)(configId, 'variable');
+                const setValues = (values) => {
+                    callback(values[configId]);
+                };
+                on('wb:plugin:variable:update', setValues);
+                return () => {
+                    off('wb:plugin:variable:update', setValues);
+                };
+            },
+            subscribeToWorkbookInteraction(configId, callback) {
+                (0, error_1.validateConfigId)(configId, 'interaction');
+                const setValues = (values) => {
+                    callback(values[configId]);
+                };
+                on('wb:plugin:selection:update', setValues);
+                return () => {
+                    off('wb:plugin:selection:update', setValues);
+                };
+            },
+            subscribeToUrlParameter(configId, callback) {
+                (0, error_1.validateConfigId)(configId, 'url-parameter');
+                const setValues = (values) => {
+                    callback(values[configId]);
+                };
+                setValues(subscribedUrlParameters);
+                on('wb:plugin:url-parameter:update', setValues);
+                return () => {
+                    off('wb:plugin:url-parameter:update', setValues);
+                };
+            },
+            getUrlParameter(configId) {
+                (0, error_1.validateConfigId)(configId, 'url-parameter');
+                return subscribedUrlParameters[configId];
+            },
+            setUrlParameter(configId, value) {
+                (0, error_1.validateConfigId)(configId, 'url-parameter');
+                void execPromise('wb:plugin:url-parameter:set', configId, value);
+            }
+        },
+        elements: {
+            getElementColumns(configId) {
+                (0, error_1.validateConfigId)(configId, 'element');
+                return execPromise('wb:plugin:element:columns:get', configId);
+            },
+            subscribeToElementColumns(configId, callback) {
+                (0, error_1.validateConfigId)(configId, 'element');
+                const eventName = `wb:plugin:element:${configId}:columns`;
+                on(eventName, callback);
+                void execPromise('wb:plugin:element:subscribe:columns', configId);
+                return () => {
+                    off(eventName, callback);
+                    void execPromise('wb:plugin:element:unsubscribe:columns', configId);
+                };
+            },
+            subscribeToElementData(configId, callback) {
+                (0, error_1.validateConfigId)(configId, 'element');
+                const eventName = `wb:plugin:element:${configId}:data`;
+                on(eventName, callback);
+                void execPromise('wb:plugin:element:subscribe:data', configId);
+                return () => {
+                    off(eventName, callback);
+                    void execPromise('wb:plugin:element:unsubscribe:data', configId);
+                };
+            },
+            fetchMoreElementData(configId) {
+                (0, error_1.validateConfigId)(configId, 'element');
+                void execPromise('wb:plugin:element:fetch-more', configId);
+            },
+        },
+        style: {
+            subscribe(callback) {
+                on('wb:plugin:style:update', callback);
+                return () => off('wb:plugin:style:update', callback);
+            },
+            get() {
+                return execPromise('wb:plugin:style:get');
+            },
+        },
+        destroy() {
+            Object.keys(listeners).forEach(event => delete listeners[event]);
+            window.removeEventListener('message', listener, false);
+        },
+    };
+}
+exports.initialize = initialize;

package/dist/react/Context.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { PluginInstance } from '../types';
+export declare const PluginContext: import("react").Context<PluginInstance<any>>;
+//# sourceMappingURL=Context.d.ts.map

package/dist/react/Context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../src/react/Context.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1C,eAAO,MAAM,aAAa,8CAAwC,CAAC"}

package/dist/react/Context.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginContext = void 0;
+const react_1 = require("react");
+const client_1 = require("../client");
+exports.PluginContext = (0, react_1.createContext)(client_1.client);

package/dist/react/Provider.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import { PluginInstance } from '../types';
+export interface SigmaClientProviderProps<T = any> {
+    client: PluginInstance<T>;
+    children?: ReactNode;
+}
+export declare function SigmaClientProvider<T = any>(props: SigmaClientProviderProps<T>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Provider.d.ts.map

package/dist/react/Provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../../src/react/Provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1C,MAAM,WAAW,wBAAwB,CAAC,CAAC,GAAG,GAAG;IAC/C,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IAC1B,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,wBAAgB,mBAAmB,CAAC,CAAC,GAAG,GAAG,EACzC,KAAK,EAAE,wBAAwB,CAAC,CAAC,CAAC,2CAOnC"}

package/dist/react/Provider.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SigmaClientProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const Context_1 = require("./Context");
+function SigmaClientProvider(props) {
+    return ((0, jsx_runtime_1.jsx)(Context_1.PluginContext.Provider, Object.assign({ value: props.client }, { children: props.children })));
+}
+exports.SigmaClientProvider = SigmaClientProvider;

package/dist/react/hooks.d.ts

@@ -0,0 +1,83 @@
+import { PluginInstance, CustomPluginConfigOptions, WorkbookElementColumns, WorkbookElementData, WorkbookVariable, PluginStyle, UrlParameter } from '../types';
+/**
+ * Gets the entire plugin instance
+ * @returns {PluginInstance} Context for the current plugin instance
+ */
+export declare function usePlugin(): PluginInstance<any>;
+/**
+ * Provides a setter for the Plugin's Config Options
+ * @param {CustomPluginConfigOptions[]} nextOptions Updated possible Config Options
+ */
+export declare function useEditorPanelConfig(nextOptions: CustomPluginConfigOptions[]): void;
+/**
+ * React hook for Plugin Config loading state
+ * @param {boolean} initialState Initial value to set loading state to
+ * @returns {[boolean, Function]} Boolean value corresponding to loading state for plugin config and setter for loading state
+ */
+export declare function useLoadingState(initialState: boolean): [boolean, (nextState: boolean) => void];
+/**
+ * Provides the latest column values from corresponding config element
+ * @param {string} configId ID from the config for fetching element columns, with type: 'element'
+ * @returns {WorkbookElementColumns} Values of corresponding columns contained
+ * within the config element
+ */
+export declare function useElementColumns(configId: string): WorkbookElementColumns;
+/**
+ * Provides the latest data values from config element (max 25_000)
+ * @param {string} configId ID from the config for fetching element data, with type: 'element'
+ * @returns {WorkbookElementData} Element Data for config element, if any
+ */
+export declare function useElementData(configId: string): WorkbookElementData;
+/**
+ * Provides the latest data values from corresponding config element with a callback to
+ * fetch more in chunks of 25_000 data points
+ * @param {string} configId ID from the config for fetching paginated
+ * element data, with type: 'element'
+ * @returns {WorkbookElementData} Element Data for configured config element, if any
+ */
+export declare function usePaginatedElementData(configId: string): [WorkbookElementData, () => void];
+/**
+ * Provides the latest value for entire config or certain key within the config
+ * @param {string} key Key within Plugin Config, optional
+ * @returns Entire config if no key passed in or value for key within plugin config
+ */
+export declare function useConfig(key?: string): any;
+/**
+ * React hook for accessing a workbook control variable
+ * @param {string} id ID from the config of type: 'variable'
+ * @returns {[(WorkbookVariable | undefined), Function]} Constantly updating
+ * value of the control variable and setter for the variable
+ */
+export declare function useVariable(id: string): [WorkbookVariable | undefined, Function];
+/**
+ * React hook for accessing a url parameter
+ * @param {string} id ID from the config of type: 'url-parameter'
+ * @returns {[(UrlParameter | undefined), Function]} Constantly updating value of the url parameter and setter for the url parameter
+ */
+export declare function useUrlParameter(id: string): [UrlParameter | undefined, (value: string) => void];
+/**
+ * @deprecated Use Action API instead
+ * React hook for accessing a workbook interaction selections state
+ * @param {string} id ID from the config of type: 'interaction'
+ * @returns {[(WorkbookSelection | undefined), Function]} Constantly updating selection state and setter thereof
+ */
+export declare function useInteraction(id: string, elementId: string): [unknown, Function];
+/**
+ * React hook for returning a triggering callback function for the registered
+ * action trigger
+ * @param {string} configId ID from the config of type: 'action-trigger'
+ * @returns {Function} A callback function to trigger the action
+ */
+export declare function useActionTrigger(configId: string): () => void;
+/**
+ * React hook for registering and unregistering an action effect
+ * @param {string} configId ID from the config of type: 'action-effect'
+ * @param {Function} effect The function to be called when the action is triggered
+ */
+export declare function useActionEffect(configId: string, effect: () => void): void;
+/**
+ * React hook for accessing plugin style with live updates
+ * @returns {PluginStyle | undefined} Style properties from the workbook if available
+ */
+export declare function usePluginStyle(): PluginStyle | undefined;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/react/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/react/hooks.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,cAAc,EACd,yBAAyB,EACzB,sBAAsB,EACtB,mBAAmB,EAEnB,gBAAgB,EAChB,WAAW,EACX,YAAY,EACb,MAAM,UAAU,CAAC;AAGlB;;;GAGG;AACH,wBAAgB,SAAS,IAAI,cAAc,CAAC,GAAG,CAAC,CAE/C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,yBAAyB,EAAE,GACvC,IAAI,CAWN;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,OAAO,GACpB,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC,CAezC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,sBAAsB,CAW1E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,CAWpE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,GACf,CAAC,mBAAmB,EAAE,MAAM,IAAI,CAAC,CAiBnC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,CAmB3C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,GACT,CAAC,gBAAgB,GAAG,SAAS,EAAE,QAAQ,CAAC,CAoB1C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,GACT,CAAC,YAAY,GAAG,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC,CAoBrD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,GAChB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAoBrB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,IAAI,CAM7D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,IAAI,QAYnE;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,WAAW,GAAG,SAAS,CAWxD"}

package/dist/react/hooks.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePluginStyle = exports.useActionEffect = exports.useActionTrigger = exports.useInteraction = exports.useUrlParameter = exports.useVariable = exports.useConfig = exports.usePaginatedElementData = exports.useElementData = exports.useElementColumns = exports.useLoadingState = exports.useEditorPanelConfig = exports.usePlugin = void 0;
+const react_1 = require("react");
+const Context_1 = require("./Context");
+const deepEqual_1 = require("../utils/deepEqual");
+/**
+ * Gets the entire plugin instance
+ * @returns {PluginInstance} Context for the current plugin instance
+ */
+function usePlugin() {
+    return (0, react_1.useContext)(Context_1.PluginContext);
+}
+exports.usePlugin = usePlugin;
+/**
+ * Provides a setter for the Plugin's Config Options
+ * @param {CustomPluginConfigOptions[]} nextOptions Updated possible Config Options
+ */
+function useEditorPanelConfig(nextOptions) {
+    const client = usePlugin();
+    const optionsRef = (0, react_1.useRef)({});
+    (0, react_1.useEffect)(() => {
+        if (nextOptions == null)
+            return;
+        if (!(0, deepEqual_1.deepEqual)(nextOptions, optionsRef.current)) {
+            client.config.configureEditorPanel(nextOptions);
+            optionsRef.current = nextOptions;
+        }
+    }, [client, nextOptions]);
+}
+exports.useEditorPanelConfig = useEditorPanelConfig;
+/**
+ * React hook for Plugin Config loading state
+ * @param {boolean} initialState Initial value to set loading state to
+ * @returns {[boolean, Function]} Boolean value corresponding to loading state for plugin config and setter for loading state
+ */
+function useLoadingState(initialState) {
+    const client = usePlugin();
+    const [loading, setLoading] = (0, react_1.useState)(() => {
+        client.config.setLoadingState(initialState);
+        return initialState;
+    });
+    return [
+        loading,
+        nextState => {
+            if (nextState === loading)
+                return;
+            setLoading(nextState);
+            client.config.setLoadingState(nextState);
+        },
+    ];
+}
+exports.useLoadingState = useLoadingState;
+/**
+ * Provides the latest column values from corresponding config element
+ * @param {string} configId ID from the config for fetching element columns, with type: 'element'
+ * @returns {WorkbookElementColumns} Values of corresponding columns contained
+ * within the config element
+ */
+function useElementColumns(configId) {
+    const client = usePlugin();
+    const [columns, setColumns] = (0, react_1.useState)({});
+    (0, react_1.useEffect)(() => {
+        if (configId) {
+            return client.elements.subscribeToElementColumns(configId, setColumns);
+        }
+    }, [client, configId]);
+    return columns;
+}
+exports.useElementColumns = useElementColumns;
+/**
+ * Provides the latest data values from config element (max 25_000)
+ * @param {string} configId ID from the config for fetching element data, with type: 'element'
+ * @returns {WorkbookElementData} Element Data for config element, if any
+ */
+function useElementData(configId) {
+    const client = usePlugin();
+    const [data, setData] = (0, react_1.useState)({});
+    (0, react_1.useEffect)(() => {
+        if (configId) {
+            return client.elements.subscribeToElementData(configId, setData);
+        }
+    }, [client, configId]);
+    return data;
+}
+exports.useElementData = useElementData;
+/**
+ * Provides the latest data values from corresponding config element with a callback to
+ * fetch more in chunks of 25_000 data points
+ * @param {string} configId ID from the config for fetching paginated
+ * element data, with type: 'element'
+ * @returns {WorkbookElementData} Element Data for configured config element, if any
+ */
+function usePaginatedElementData(configId) {
+    const client = usePlugin();
+    const [data, setData] = (0, react_1.useState)({});
+    const loadMore = (0, react_1.useCallback)(() => {
+        if (configId) {
+            client.elements.fetchMoreElementData(configId);
+        }
+    }, [configId]);
+    (0, react_1.useEffect)(() => {
+        if (configId) {
+            return client.elements.subscribeToElementData(configId, setData);
+        }
+    }, [client, configId]);
+    return [data, loadMore];
+}
+exports.usePaginatedElementData = usePaginatedElementData;
+/**
+ * Provides the latest value for entire config or certain key within the config
+ * @param {string} key Key within Plugin Config, optional
+ * @returns Entire config if no key passed in or value for key within plugin config
+ */
+function useConfig(key) {
+    const client = usePlugin();
+    const [config, setConfig] = (0, react_1.useState)(key != null ? client.config.getKey(key) : client.config.get());
+    (0, react_1.useEffect)(() => client.config.subscribe(newConfig => {
+        if (key != null && newConfig[key] !== config[key]) {
+            setConfig(newConfig[key]);
+        }
+        else {
+            setConfig(newConfig);
+        }
+    }), [client]);
+    return config;
+}
+exports.useConfig = useConfig;
+/**
+ * React hook for accessing a workbook control variable
+ * @param {string} id ID from the config of type: 'variable'
+ * @returns {[(WorkbookVariable | undefined), Function]} Constantly updating
+ * value of the control variable and setter for the variable
+ */
+function useVariable(id) {
+    const client = usePlugin();
+    const [workbookVariable, setWorkbookVariable] = (0, react_1.useState)();
+    const isFirstRender = (0, react_1.useRef)(true);
+    (0, react_1.useEffect)(() => {
+        if (isFirstRender.current) {
+            setWorkbookVariable(client.config.getVariable(id));
+            isFirstRender.current = false;
+        }
+        return client.config.subscribeToWorkbookVariable(id, setWorkbookVariable);
+    }, [client, id]);
+    const setVariable = (0, react_1.useCallback)((...values) => client.config.setVariable(id, ...values), [id]);
+    return [workbookVariable, setVariable];
+}
+exports.useVariable = useVariable;
+/**
+ * React hook for accessing a url parameter
+ * @param {string} id ID from the config of type: 'url-parameter'
+ * @returns {[(UrlParameter | undefined), Function]} Constantly updating value of the url parameter and setter for the url parameter
+ */
+function useUrlParameter(id) {
+    const client = usePlugin();
+    const [urlParameter, setUrlParameter] = (0, react_1.useState)();
+    const isFirstRender = (0, react_1.useRef)(true);
+    (0, react_1.useEffect)(() => {
+        if (isFirstRender.current) {
+            setUrlParameter(client.config.getUrlParameter(id));
+            isFirstRender.current = false;
+        }
+        return client.config.subscribeToUrlParameter(id, setUrlParameter);
+    }, [client, id]);
+    const setter = (0, react_1.useCallback)((value) => client.config.setUrlParameter(id, value), [client, id]);
+    return [urlParameter, setter];
+}
+exports.useUrlParameter = useUrlParameter;
+/**
+ * @deprecated Use Action API instead
+ * React hook for accessing a workbook interaction selections state
+ * @param {string} id ID from the config of type: 'interaction'
+ * @returns {[(WorkbookSelection | undefined), Function]} Constantly updating selection state and setter thereof
+ */
+function useInteraction(id, elementId) {
+    const client = usePlugin();
+    const [workbookInteraction, setWorkbookInteraction] = (0, react_1.useState)();
+    (0, react_1.useEffect)(() => {
+        return client.config.subscribeToWorkbookInteraction(id, setWorkbookInteraction);
+    }, [client, id]);
+    const setInteraction = (0, react_1.useCallback)((value) => {
+        client.config.setInteraction(id, elementId, value);
+    }, [id]);
+    return [workbookInteraction, setInteraction];
+}
+exports.useInteraction = useInteraction;
+/**
+ * React hook for returning a triggering callback function for the registered
+ * action trigger
+ * @param {string} configId ID from the config of type: 'action-trigger'
+ * @returns {Function} A callback function to trigger the action
+ */
+function useActionTrigger(configId) {
+    const client = usePlugin();
+    return (0, react_1.useCallback)(() => {
+        client.config.triggerAction(configId);
+    }, [client, configId]);
+}
+exports.useActionTrigger = useActionTrigger;
+/**
+ * React hook for registering and unregistering an action effect
+ * @param {string} configId ID from the config of type: 'action-effect'
+ * @param {Function} effect The function to be called when the action is triggered
+ */
+function useActionEffect(configId, effect) {
+    const client = usePlugin();
+    const effectRef = (0, react_1.useRef)(effect);
+    (0, react_1.useEffect)(() => {
+        effectRef.current = effect;
+    });
+    (0, react_1.useEffect)(() => {
+        return client.config.registerEffect(configId, effectRef.current);
+    }, [client, configId, effect]);
+}
+exports.useActionEffect = useActionEffect;
+/**
+ * React hook for accessing plugin style with live updates
+ * @returns {PluginStyle | undefined} Style properties from the workbook if available
+ */
+function usePluginStyle() {
+    const client = usePlugin();
+    const [style, setStyle] = (0, react_1.useState)();
+    (0, react_1.useEffect)(() => {
+        // Request initial style data on mount and subscribe to updates
+        void client.style.get().then(response => setStyle(response));
+        return client.style.subscribe(setStyle);
+    }, [client]);
+    return style;
+}
+exports.usePluginStyle = usePluginStyle;

package/dist/utils/deepEqual.d.ts

@@ -0,0 +1,2 @@
+export declare function deepEqual(obj1: any, obj2: any): boolean | undefined;
+//# sourceMappingURL=deepEqual.d.ts.map

package/dist/utils/deepEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepEqual.d.ts","sourceRoot":"","sources":["../../src/utils/deepEqual.ts"],"names":[],"mappings":"AAQA,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,uBAc7C"}

package/dist/utils/deepEqual.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEqual = void 0;
+function isObject(obj) {
+    if (typeof obj === 'object' && obj != null) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    else if (isObject(obj1) && isObject(obj2)) {
+        if (Object.keys(obj1).length !== Object.keys(obj2).length) {
+            return false;
+        }
+        for (const prop in obj1) {
+            if (!deepEqual(obj1[prop], obj2[prop])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.deepEqual = deepEqual;

package/dist/utils/polyfillRequestAnimationFrame.d.ts

@@ -0,0 +1,8 @@
+/**
+ * requestAnimationFrame() calls are paused in most browsers when running in background tabs or hidden <iframe>s in order to improve performance and battery life
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame
+ * @param w Window Object
+ */
+export declare function polyfillRequestAnimationFrame(w: Window): void;
+//# sourceMappingURL=polyfillRequestAnimationFrame.d.ts.map

package/dist/utils/polyfillRequestAnimationFrame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfillRequestAnimationFrame.d.ts","sourceRoot":"","sources":["../../src/utils/polyfillRequestAnimationFrame.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,EAAE,MAAM,QAKtD"}

package/dist/utils/polyfillRequestAnimationFrame.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polyfillRequestAnimationFrame = void 0;
+/**
+ * requestAnimationFrame() calls are paused in most browsers when running in background tabs or hidden <iframe>s in order to improve performance and battery life
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame
+ * @param w Window Object
+ */
+function polyfillRequestAnimationFrame(w) {
+    if ('requestAnimationFrame' in w) {
+        w.requestAnimationFrame = cb => w.setTimeout(cb, 1000 / 60);
+        w.cancelAnimationFrame = id => w.clearTimeout(id);
+    }
+}
+exports.polyfillRequestAnimationFrame = polyfillRequestAnimationFrame;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sigmacomputing/plugin",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Sigma Computing Plugin Client API",
   "license": "MIT",
   "homepage": "https://github.com/sigmacomputing/plugin",
@@ -15,7 +15,7 @@
   },
   "packageManager": "yarn@4.4.1",
   "files": [
-    "dist/*"
+    "dist/**/*"
   ],
   "typesVersions": {
     "*": {
@@ -24,6 +24,9 @@
       ]
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "yarn tsc --build tsconfig.build.json",
     "build:watch": "yarn build --watch",