@tomorrowevening/theatre-studio 1.0.4 → 1.0.5

package/dist/uiComponents/useOnKeyDown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnKeyDown.d.ts","sourceRoot":"","sources":["../../../../../studio/src/uiComponents/useOnKeyDown.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,aAAa,KAAK,IAAI,QAUzE"}

package/dist/uiComponents/useOnKeyDown.js

@@ -0,0 +1,12 @@
+import { useEffect, useRef } from 'react';
+export default function useOnKeyDown(callback) {
+    const ref = useRef(callback);
+    ref.current = callback;
+    useEffect(() => {
+        const onKeyDown = (ev) => ref.current(ev);
+        window.addEventListener('keydown', onKeyDown);
+        return () => {
+            window.removeEventListener('keydown', onKeyDown);
+        };
+    }, []);
+}

package/dist/uiComponents/usePresence.d.ts

@@ -0,0 +1,30 @@
+import type { StudioSheetItemKey } from '@tomorrowevening/theatre-shared/utils/ids';
+import React from 'react';
+/** To mean the presence value */
+export declare enum PresenceFlag {
+    /** Self is hovered or what represents "self" is being hovered */
+    Primary = 2,
+    /** Related item is hovered */
+    Secondary = 1
+}
+type FlagRelationConfig = {
+    affects: StudioSheetItemKey;
+    /** adds this flag to affects */
+    flag: PresenceFlag;
+};
+type InternalPresenceContext = {
+    usePresenceFlag(itemKey: StudioSheetItemKey | undefined): PresenceFlag | undefined;
+    setUserHover(itemKey: StudioSheetItemKey | undefined): void;
+    addRelatedFlags(itemKey: StudioSheetItemKey, config: Array<FlagRelationConfig>): () => void;
+};
+export declare function ProvidePresenceRoot({ children }: React.PropsWithChildren<{}>): React.FunctionComponentElement<React.ProviderProps<InternalPresenceContext>>;
+export default function usePresence(key: StudioSheetItemKey | undefined): {
+    attrs: {
+        [attr: `data-${string}`]: string;
+    };
+    flag: PresenceFlag | undefined;
+    useRelations(getRelations: () => Array<FlagRelationConfig>, deps: any[]): void;
+};
+export declare function usePresenceListenersOnRootElement(target: HTMLElement | null | undefined): void;
+export {};
+//# sourceMappingURL=usePresence.d.ts.map

package/dist/uiComponents/usePresence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePresence.d.ts","sourceRoot":"","sources":["../../../../../studio/src/uiComponents/usePresence.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,2CAA2C,CAAA;AAEjF,OAAO,KAAgB,MAAM,OAAO,CAAA;AASpC,iCAAiC;AACjC,oBAAY,YAAY;IACtB,iEAAiE;IACjE,OAAO,IAAI;IACX,8BAA8B;IAC9B,SAAS,IAAI;CAGd;AAoGD,KAAK,kBAAkB,GAAG;IACxB,OAAO,EAAE,kBAAkB,CAAA;IAC3B,gCAAgC;IAChC,IAAI,EAAE,YAAY,CAAA;CACnB,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B,eAAe,CACb,OAAO,EAAE,kBAAkB,GAAG,SAAS,GACtC,YAAY,GAAG,SAAS,CAAA;IAC3B,YAAY,CAAC,OAAO,EAAE,kBAAkB,GAAG,SAAS,GAAG,IAAI,CAAA;IAC3D,eAAe,CACb,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,KAAK,CAAC,kBAAkB,CAAC,GAChC,MAAM,IAAI,CAAA;CACd,CAAA;AAKD,wBAAgB,mBAAmB,CAAC,EAAC,QAAQ,EAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,EAAE,CAAC,gFAO1E;AAID,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,GAAG,EAAE,kBAAkB,GAAG,SAAS,GAAG;IACxE,KAAK,EAAE;QAAC,CAAC,IAAI,EAAE,QAAQ,MAAM,EAAE,GAAG,MAAM,CAAA;KAAC,CAAA;IACzC,IAAI,EAAE,YAAY,GAAG,SAAS,CAAA;IAC9B,YAAY,CAAC,YAAY,EAAE,MAAM,KAAK,CAAC,kBAAkB,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAA;CAC/E,CAeA;AAED,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,QA8CvC"}

package/dist/uiComponents/usePresence.js

@@ -0,0 +1,156 @@
+import React, { useMemo } from 'react';
+import { useEffect } from 'react';
+import { useLogger } from './useLogger';
+import { prism, pointerToPrism } from '@tomorrowevening/theatre-dataverse';
+import { Atom } from '@tomorrowevening/theatre-dataverse';
+import { usePrismInstance } from '@tomorrowevening/theatre-react';
+import { selectClosestHTMLAncestor } from '@tomorrowevening/theatre-studio/utils/selectClosestHTMLAncestor';
+import pointerDeep from '@tomorrowevening/theatre-shared/utils/pointerDeep';
+/** To mean the presence value */
+export var PresenceFlag;
+(function (PresenceFlag) {
+    /** Self is hovered or what represents "self" is being hovered */
+    PresenceFlag[PresenceFlag["Primary"] = 2] = "Primary";
+    /** Related item is hovered */
+    PresenceFlag[PresenceFlag["Secondary"] = 1] = "Secondary";
+    // /** Tutorial */
+    // TutorialEmphasis = 0,
+})(PresenceFlag || (PresenceFlag = {}));
+const undefinedD = prism(() => undefined);
+undefinedD.keepHot(); // constant anyway...
+function createPresenceContext(options) {
+    const currentUserHoverItemB = new Atom(undefined);
+    const currentUserHoverFlagItemsAtom = new Atom({});
+    // keep as part of presence creation
+    const relationsAtom = new Atom({});
+    let lastRelationId = 0;
+    return {
+        addRelatedFlags(itemKey, relationships) {
+            const relationId = String(++lastRelationId);
+            // "clean up" paths returned from relationships declared
+            const undoAtPaths = relationships.map((rel) => {
+                const presence = {
+                    flag: rel.flag,
+                };
+                const path = [rel.affects, itemKey, relationId];
+                relationsAtom.setByPointer((p) => pointerDeep(p, path), presence);
+                return path;
+            });
+            return () => {
+                for (const pathToUndo of undoAtPaths) {
+                    relationsAtom.setByPointer((p) => pointerDeep(p, pathToUndo), undefined);
+                }
+            };
+        },
+        usePresenceFlag(itemKey) {
+            if (!options.enabled)
+                return undefined;
+            const focusD = useMemo(() => {
+                if (!itemKey)
+                    return undefinedD;
+                // this is the thing being hovered
+                const currentD = currentUserHoverItemB.prism;
+                const primaryFocusDer = pointerToPrism(currentUserHoverFlagItemsAtom.pointer[itemKey]);
+                const relationsDer = pointerToPrism(relationsAtom.pointer[itemKey]);
+                return prism(() => {
+                    const primary = primaryFocusDer.getValue();
+                    if (primary) {
+                        return PresenceFlag.Primary;
+                    }
+                    else {
+                        const related = relationsDer.getValue();
+                        const current = currentD.getValue();
+                        const rels = related && current && related[current];
+                        if (rels) {
+                            // can this be cached into a derived atom?
+                            let best;
+                            for (const rel of Object.values(rels)) {
+                                if (!rel)
+                                    continue;
+                                if (best && best >= rel.flag)
+                                    continue;
+                                best = rel.flag;
+                            }
+                            return best;
+                        }
+                        return undefined;
+                    }
+                });
+            }, [itemKey]);
+            return usePrismInstance(focusD);
+        },
+        setUserHover(itemKeyOpt) {
+            const prev = currentUserHoverItemB.get();
+            if (prev === itemKeyOpt) {
+                return;
+            }
+            if (prev) {
+                currentUserHoverFlagItemsAtom.setByPointer((p) => p[prev], false);
+            }
+            currentUserHoverItemB.set(itemKeyOpt);
+            if (itemKeyOpt) {
+                currentUserHoverFlagItemsAtom.setByPointer((p) => p[itemKeyOpt], true);
+            }
+        },
+    };
+}
+const presenceInternalCtx = React.createContext(createPresenceContext({ enabled: false }));
+export function ProvidePresenceRoot({ children }) {
+    const presence = useMemo(() => createPresenceContext({ enabled: false }), []);
+    return React.createElement(presenceInternalCtx.Provider, { children, value: presence }, children);
+}
+const PRESENCE_ITEM_DATA_ATTR = 'data-pi-key';
+export default function usePresence(key) {
+    const presenceInternal = React.useContext(presenceInternalCtx);
+    const flag = presenceInternal.usePresenceFlag(key);
+    return {
+        attrs: {
+            [PRESENCE_ITEM_DATA_ATTR]: key,
+        },
+        flag,
+        useRelations(getRelations, deps) {
+            useEffect(() => {
+                return key && presenceInternal.addRelatedFlags(key, getRelations());
+            }, [key, ...deps]);
+        },
+    };
+}
+export function usePresenceListenersOnRootElement(target) {
+    const presence = React.useContext(presenceInternalCtx);
+    const logger = useLogger('PresenceListeners');
+    useEffect(() => {
+        // keep track of current primary hover to make sure we make changes to presence distinct
+        let currentItemKeyUserHover;
+        if (!target)
+            return;
+        const onMouseOver = (event) => {
+            if (event.target instanceof Node) {
+                const found = selectClosestHTMLAncestor(event.target, `[${PRESENCE_ITEM_DATA_ATTR}]`);
+                if (found) {
+                    const itemKey = found.getAttribute(PRESENCE_ITEM_DATA_ATTR);
+                    if (currentItemKeyUserHover !== itemKey) {
+                        currentItemKeyUserHover = itemKey;
+                        presence.setUserHover((itemKey || undefined));
+                        logger._debug('Updated current hover', { itemKey });
+                    }
+                    return;
+                }
+                // remove hover
+                if (currentItemKeyUserHover != null) {
+                    currentItemKeyUserHover = null;
+                    presence.setUserHover(undefined);
+                    logger._debug('Cleared current hover');
+                }
+            }
+        };
+        target.addEventListener('mouseover', onMouseOver);
+        return () => {
+            target.removeEventListener('mouseover', onMouseOver);
+            // remove hover
+            if (currentItemKeyUserHover != null) {
+                currentItemKeyUserHover = null;
+                logger._debug('Cleared current hover as part of cleanup');
+            }
+        };
+    }, [target, presence]);
+}

package/dist/uiComponents/useValToAtom.d.ts

@@ -0,0 +1,3 @@
+import { Atom } from '@tomorrowevening/theatre-dataverse';
+export default function useValToAtom<S>(val: S): Atom<S>;
+//# sourceMappingURL=useValToAtom.d.ts.map

package/dist/uiComponents/useValToAtom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useValToAtom.d.ts","sourceRoot":"","sources":["../../../../../studio/src/uiComponents/useValToAtom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,oCAAoC,CAAA;AAGvD,MAAM,CAAC,OAAO,UAAU,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAUvD"}

package/dist/uiComponents/useValToAtom.js

@@ -0,0 +1,11 @@
+import { Atom } from '@tomorrowevening/theatre-dataverse';
+import { useLayoutEffect, useMemo } from 'react';
+export default function useValToAtom(val) {
+    const atom = useMemo(() => {
+        return new Atom(val);
+    }, []);
+    useLayoutEffect(() => {
+        atom.set(val);
+    }, [val]);
+    return atom;
+}

package/dist/utils/absoluteDims.d.ts

@@ -0,0 +1,3 @@
+/** Create CSS rule string for centered and give it this width and height */
+export declare const absoluteDims: (w: number, h?: number) => string;
+//# sourceMappingURL=absoluteDims.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"absoluteDims.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/absoluteDims.tsx"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,eAAO,MAAM,YAAY,MAAO,MAAM,uBAKrC,CAAA"}

package/dist/utils/absoluteDims.js

@@ -0,0 +1,7 @@
+/** Create CSS rule string for centered and give it this width and height */
+export const absoluteDims = (w, h = w) => `
+  left: ${w * -0.5}px;
+  top: ${h * -0.5}px;
+  width: ${w}px;
+  height: ${h}px;
+`;

package/dist/utils/contextualWebComponents.d.ts

@@ -0,0 +1,5 @@
+import type React from 'react';
+export declare function registerContextualWebComponent<Props>(ReactComponent: React.ComponentType<Props>, componentName: string, propKeys: {
+    [propKey in keyof Props]: 'string';
+}): void;
+//# sourceMappingURL=contextualWebComponents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contextualWebComponents.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/contextualWebComponents.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,wBAAgB,8BAA8B,CAAC,KAAK,EAClD,cAAc,EAAE,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,EAC1C,aAAa,EAAE,MAAM,EAErB,QAAQ,EAAE;KAAE,OAAO,IAAI,MAAM,KAAK,GAAG,QAAQ;CAAC,GAC7C,IAAI,CAgDN"}

package/dist/utils/contextualWebComponents.js

@@ -0,0 +1,44 @@
+import { getMounter } from './renderInPortalInContext';
+export function registerContextualWebComponent(ReactComponent, componentName, 
+// currently only supporting string prop types
+propKeys) {
+    if (typeof window === 'undefined' || typeof customElements === 'undefined')
+        return;
+    const propList = Object.keys(propKeys);
+    class CustomWebComponent extends HTMLElement {
+        _mounted = false;
+        _mountOrRender;
+        _unmount;
+        static get observedAttributes() {
+            return propList;
+        }
+        constructor() {
+            super();
+            const { mountOrRender, unmount } = getMounter();
+            this._mountOrRender = mountOrRender;
+            this._unmount = unmount;
+        }
+        connectedCallback() {
+            // const shadow = this.attachShadow({mode: 'open'})
+            this._mounted = true;
+            this._render();
+        }
+        _render() {
+            const props = Object.fromEntries(propList.map((propName) => [
+                propName,
+                this.getAttribute(propName),
+            ]));
+            this._mountOrRender(ReactComponent, props, this);
+        }
+        attributeChangedCallback() {
+            if (!this._mounted)
+                return;
+            this._render();
+        }
+        disconnectedCallback() {
+            this._mounted = false;
+            this._unmount();
+        }
+    }
+    customElements.define(componentName, CustomWebComponent);
+}

package/dist/utils/copyToClipboard.d.ts

@@ -0,0 +1,2 @@
+export declare function copyToClipboard(text: string): Promise<boolean>;
+//# sourceMappingURL=copyToClipboard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"copyToClipboard.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/copyToClipboard.ts"],"names":[],"mappings":"AAAA,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAyBpE"}

package/dist/utils/copyToClipboard.js

@@ -0,0 +1,28 @@
+export async function copyToClipboard(text) {
+    if (navigator.clipboard) {
+        return navigator.clipboard
+            .writeText(text)
+            .then(() => {
+            return true;
+        })
+            .catch(() => {
+            return false;
+        });
+    }
+    else {
+        const tempTextArea = document.createElement('textarea');
+        tempTextArea.value = text;
+        document.body.appendChild(tempTextArea);
+        tempTextArea.focus();
+        tempTextArea.select();
+        try {
+            const successful = document.execCommand('copy');
+            document.body.removeChild(tempTextArea);
+            return Promise.resolve(successful);
+        }
+        catch (err) {
+            document.body.removeChild(tempTextArea);
+            return Promise.resolve(false);
+        }
+    }
+}

package/dist/utils/derive-utils.d.ts

@@ -0,0 +1,21 @@
+import type { Prism, Pointer } from '@tomorrowevening/theatre-dataverse';
+import React from 'react';
+export type $<T> = Prism<T> | Pointer<T>;
+/** This is only used for type checking to make sure the APIs are used properly */
+interface TSErrors<M> extends Error {
+}
+type ReactDeriver<Props extends {}> = (props: {
+    [P in keyof Props]: Props[P] extends Prism<infer _> ? TSErrors<"Can't both use Derivation properties while wrapping with deriver"> : Props[P] | Prism<Props[P]>;
+}) => React.ReactElement | null;
+/**
+ * Wrap up the component to enable it to take derivable properties.
+ * Invoked similarly to `React.memo`.
+ *
+ * @remarks
+ * This is an experimental interface for wrapping components in a version
+ * which allows you to pass in derivations for any of the properties that
+ * previously took only values.
+ */
+export declare function deriver<Props extends {}>(Component: React.ComponentType<Props>): ReactDeriver<Omit<Props, keyof JSX.IntrinsicAttributes>>;
+export {};
+//# sourceMappingURL=derive-utils.d.ts.map

package/dist/utils/derive-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive-utils.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/derive-utils.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,KAAK,EAAE,OAAO,EAAC,MAAM,oCAAoC,CAAA;AAGtE,OAAO,KAAwB,MAAM,OAAO,CAAA;AAS5C,MAAM,MAAM,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;AAwBxC,kFAAkF;AAClF,UAAU,QAAQ,CAAC,CAAC,CAAE,SAAQ,KAAK;CAAG;AAEtC,KAAK,YAAY,CAAC,KAAK,SAAS,EAAE,IAAI,CACpC,KAAK,EAAE;KACJ,CAAC,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAC/C,QAAQ,CAAC,kEAAkE,CAAC,GAC5E,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;CAC/B,KACE,KAAK,CAAC,YAAY,GAAG,IAAI,CAAA;AAE9B;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,KAAK,SAAS,EAAE,EACtC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,GACpC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,mBAAmB,CAAC,CAAC,CA4C1D"}

package/dist/utils/derive-utils.js

@@ -0,0 +1,61 @@
+import { isPrism, prism, val } from '@tomorrowevening/theatre-dataverse';
+import { usePrismInstance } from '@tomorrowevening/theatre-react';
+import React, { useMemo, useRef } from 'react';
+import { invariant } from './invariant';
+function deriveAllD(obj) {
+    return prism(() => {
+        if (Array.isArray(obj)) {
+            const values = new Array(obj.length);
+            for (let i = 0; i < obj.length; i++) {
+                values[i] = obj[i].getValue();
+            }
+            return values;
+        }
+        else {
+            const values = {};
+            for (const k in obj) {
+                values[k] = val(obj[k]);
+            }
+            return values;
+        }
+    });
+}
+/**
+ * Wrap up the component to enable it to take derivable properties.
+ * Invoked similarly to `React.memo`.
+ *
+ * @remarks
+ * This is an experimental interface for wrapping components in a version
+ * which allows you to pass in derivations for any of the properties that
+ * previously took only values.
+ */
+export function deriver(Component) {
+    const finalComp = React.memo(React.forwardRef(function deriverRender(props, ref) {
+        let observableArr = [];
+        const observables = {};
+        const normalProps = {
+            ref,
+        };
+        for (const key in props) {
+            const value = props[key];
+            if (isPrism(value)) {
+                observableArr.push(value);
+                observables[key] = value;
+            }
+            else {
+                normalProps[key] = value;
+            }
+        }
+        const initialCount = useRef(observableArr.length);
+        invariant(initialCount.current === observableArr.length, `expect same number of observable props on every invocation of deriver wrapped component.`, { initial: initialCount.current, count: observableArr.length });
+        const allD = useMemo(() => deriveAllD(observables), observableArr);
+        const observedPropState = usePrismInstance(allD);
+        return (observedPropState &&
+            React.createElement(Component, {
+                ...normalProps,
+                ...observedPropState,
+            }));
+    }));
+    finalComp.displayName = `deriver(${Component.displayName})`;
+    return finalComp;
+}

package/dist/utils/devStringify.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Stringifies any value given. If an object is given and `indentJSON` is true,
+ * then a developer-readable, command line friendly (not too spaced out, but with
+ * enough whitespace to be readable).
+ */
+export declare function devStringify(input: any, indentJSON?: boolean): string;
+//# sourceMappingURL=devStringify.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"devStringify.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/devStringify.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,EAAE,UAAU,GAAE,OAAc,GAAG,MAAM,CAY3E"}

package/dist/utils/devStringify.js

@@ -0,0 +1,20 @@
+import { tightJsonStringify } from './tightJsonStringify';
+/**
+ * Stringifies any value given. If an object is given and `indentJSON` is true,
+ * then a developer-readable, command line friendly (not too spaced out, but with
+ * enough whitespace to be readable).
+ */
+export function devStringify(input, indentJSON = true) {
+    try {
+        return typeof input === 'string'
+            ? input
+            : typeof input === 'function' || input instanceof Error
+                ? input.toString()
+                : indentJSON
+                    ? tightJsonStringify(input)
+                    : JSON.stringify(input);
+    }
+    catch (err) {
+        return input?.name || String(input);
+    }
+}

package/dist/utils/invariant.d.ts

@@ -0,0 +1,35 @@
+type AllowedMessageTypes = string | number | object;
+/**
+ * invariants are like `expect` from jest or another testing library but
+ * for use in implementations and not just tests. If the `condition` passed
+ * to `invariant` is falsy then `message`, and optionally `found`, are thrown as a
+ * {@link InvariantError} which has a developer-readable and command line friendly
+ * stack trace and error message.
+ */
+export declare function invariant(shouldBeTruthy: any, message: (() => AllowedMessageTypes) | AllowedMessageTypes, butFoundInstead?: any): asserts shouldBeTruthy;
+/**
+ * Throws an error message with a developer-readable and command line friendly
+ * string of the argument `butFoundInstead`.
+ *
+ * Also see {@link invariant}, which accepts a condition.
+ */
+export declare function invariantThrow(message: (() => AllowedMessageTypes) | AllowedMessageTypes, butFoundInstead?: any): never;
+/**
+ * Enable exhaustive checking
+ *
+ * @example
+ * ```ts
+ * function a(x: 'a' | 'b') {
+ *   if (x === 'a') {
+ *
+ *   } else if (x === 'b') {
+ *
+ *   } else {
+ *     invariantUnreachable(x)
+ *   }
+ * }
+ * ```
+ */
+export declare function invariantUnreachable(x: never): never;
+export {};
+//# sourceMappingURL=invariant.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"invariant.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/invariant.ts"],"names":[],"mappings":"AAEA,KAAK,mBAAmB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;AAEnD;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,cAAc,EAAE,GAAG,EACnB,OAAO,EAAE,CAAC,MAAM,mBAAmB,CAAC,GAAG,mBAAmB,EAC1D,eAAe,CAAC,EAAE,GAAG,GACpB,OAAO,CAAC,cAAc,CASxB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,CAAC,MAAM,mBAAmB,CAAC,GAAG,mBAAmB,EAC1D,eAAe,CAAC,EAAE,GAAG,GACpB,KAAK,CASP;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAKpD"}

package/dist/utils/invariant.js

@@ -0,0 +1,79 @@
+import { devStringify } from './devStringify';
+/**
+ * invariants are like `expect` from jest or another testing library but
+ * for use in implementations and not just tests. If the `condition` passed
+ * to `invariant` is falsy then `message`, and optionally `found`, are thrown as a
+ * {@link InvariantError} which has a developer-readable and command line friendly
+ * stack trace and error message.
+ */
+export function invariant(shouldBeTruthy, message, butFoundInstead) {
+    if (!shouldBeTruthy) {
+        const isFoundArgGiven = arguments.length > 2;
+        if (isFoundArgGiven) {
+            invariantThrow(message, butFoundInstead);
+        }
+        else {
+            invariantThrow(message);
+        }
+    }
+}
+/**
+ * Throws an error message with a developer-readable and command line friendly
+ * string of the argument `butFoundInstead`.
+ *
+ * Also see {@link invariant}, which accepts a condition.
+ */
+export function invariantThrow(message, butFoundInstead) {
+    const isFoundArgGiven = arguments.length > 1;
+    const prefix = devStringify(typeof message === 'function' ? message() : message);
+    const suffix = isFoundArgGiven
+        ? `\nInstead found: ${devStringify(butFoundInstead)}`
+        : '';
+    throw new InvariantError(`Invariant: ${prefix}${suffix}`, butFoundInstead);
+}
+/**
+ * Enable exhaustive checking
+ *
+ * @example
+ * ```ts
+ * function a(x: 'a' | 'b') {
+ *   if (x === 'a') {
+ *
+ *   } else if (x === 'b') {
+ *
+ *   } else {
+ *     invariantUnreachable(x)
+ *   }
+ * }
+ * ```
+ */
+export function invariantUnreachable(x) {
+    invariantThrow('invariantUnreachable encountered value which was supposed to be never', x);
+}
+// regexes to remove lines from thrown error stacktraces
+const AT_NODE_INTERNAL_RE = /^\s*at.+node:internal.+/gm;
+const AT_INVARIANT_RE = /^\s*(at|[^@]+@) (?:Object\.)?invariant.+/gm;
+const AT_TEST_HELPERS_RE = /^\s*(at|[^@]+@).+test\-helpers.+/gm;
+// const AT_WEB_MODULES = /^\s*(at|[^@]+@).+(web_modules|\-[a-f0-9]{8}\.js).*/gm
+const AT_ASSORTED_HELPERS_RE = /^\s*(at|[^@]+@).+(debounce|invariant|iif)\.[tj]s.*/gm;
+/**
+ * `InvariantError` removes lines from the `Error.stack` stack trace string
+ * which cleans up the stack trace, making it more developer friendly to read.
+ */
+class InvariantError extends Error {
+    found;
+    constructor(message, found) {
+        super(message);
+        if (found !== undefined) {
+            this.found = found;
+        }
+        // const before = this.stack
+        // prettier-ignore
+        this.stack = this.stack
+            ?.replace(AT_INVARIANT_RE, "")
+            .replace(AT_ASSORTED_HELPERS_RE, "")
+            .replace(AT_TEST_HELPERS_RE, "")
+            .replace(AT_NODE_INTERNAL_RE, "");
+        // console.error({ before, after: this.stack })
+    }
+}

package/dist/utils/isMac.d.ts

@@ -0,0 +1,2 @@
+export declare const isMac: boolean;
+//# sourceMappingURL=isMac.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isMac.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/isMac.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,SAEoC,CAAA"}

package/dist/utils/isMac.js

@@ -0,0 +1,2 @@
+export const isMac = typeof navigator !== 'undefined' &&
+    navigator.platform.toUpperCase().indexOf('MAC') >= 0;

package/dist/utils/keyboardUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * On mac, it checks Cmd, on windows, ctrl
+ */
+export declare const cmdIsDown: (e: KeyboardEvent | MouseEvent) => boolean;
+/**
+ * On mac, it checks for ctrl, on windows, Win
+ */
+export declare const ctrlIsDown: (e: KeyboardEvent | MouseEvent) => boolean;
+//# sourceMappingURL=keyboardUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keyboardUtils.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/keyboardUtils.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,SAAS,MAAO,aAAa,GAAG,UAAU,YAMtD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,MAAO,aAAa,GAAG,UAAU,YAMvD,CAAA"}

package/dist/utils/keyboardUtils.js

@@ -0,0 +1,23 @@
+import { isMac } from './isMac';
+/**
+ * On mac, it checks Cmd, on windows, ctrl
+ */
+export const cmdIsDown = (e) => {
+    if (isMac) {
+        return e.metaKey === true;
+    }
+    else {
+        return e.ctrlKey === true;
+    }
+};
+/**
+ * On mac, it checks for ctrl, on windows, Win
+ */
+export const ctrlIsDown = (e) => {
+    if (isMac) {
+        return e.ctrlKey === true;
+    }
+    else {
+        return e.metaKey === true;
+    }
+};

package/dist/utils/mousePositionD.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A prism that holds the current mouse position.
+ */
+declare const mousePositionD: import("@tomorrowevening/theatre-dataverse").Prism<MouseEvent | null>;
+export default mousePositionD;
+//# sourceMappingURL=mousePositionD.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mousePositionD.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/mousePositionD.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,QAAA,MAAM,cAAc,uEAkBlB,CAAA;AAEF,eAAe,cAAc,CAAA"}