@tomorrowevening/theatre-studio 1.0.5 → 1.0.6

package/dist/utils/derive-utils.js

@@ -1,61 +0,0 @@
-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.js

@@ -1,20 +0,0 @@
-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.js

@@ -1,79 +0,0 @@
-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.js

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

package/dist/utils/keyboardUtils.js

@@ -1,23 +0,0 @@
-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.js

@@ -1,18 +0,0 @@
-import { prism } from '@tomorrowevening/theatre-dataverse';
-/**
- * A prism that holds the current mouse position.
- */
-const mousePositionD = prism(() => {
-    const [pos, setPos] = prism.state('pos', null);
-    prism.effect('setupListeners', () => {
-        const handleMouseMove = (e) => {
-            setPos(e);
-        };
-        document.addEventListener('mousemove', handleMouseMove);
-        return () => {
-            document.removeEventListener('mousemove', handleMouseMove);
-        };
-    }, []);
-    return pos;
-});
-export default mousePositionD;

package/dist/utils/redux/actionCreator.js

@@ -1,15 +0,0 @@
-function identity(a) {
-    return a;
-}
-/**
- * This is basically the same as `{createAction}` from 'redux-actions',
- * only that you can query the type of the action from the resulting
- * action creator.
- */
-const actionCreator = (actionType, transformer = identity) => {
-    const originalActionCreator = (payload) => ({ type: actionType, payload: transformer(payload) });
-    originalActionCreator.type = actionType;
-    originalActionCreator.is = (o) => o && o.type && o.type === actionType;
-    return originalActionCreator;
-};
-export default actionCreator;

package/dist/utils/redux/actionCreator.test.js

@@ -1,35 +0,0 @@
-import actionCreator from '@tomorrowevening/theatre-studio/utils/redux/actionCreator';
-describe('@tomorrowevening/theatre-studio/utils/redux/actionCreator()', () => {
-    const actionType = 'Bootstrap';
-    const payload = { a: 1, b: 2 };
-    let creator = actionCreator(actionType);
-    beforeEach(() => {
-        creator = actionCreator(actionType);
-    });
-    describe('output action', () => {
-        it('should maintain the same type and payload', () => {
-            const output = creator(payload);
-            expect(output.type).toEqual(actionType);
-            expect(output.payload).toEqual(payload);
-        });
-    });
-    describe('the action creator', () => {
-        it('should have a reference to the original action type', () => {
-            expect(creator.type).toEqual(actionType);
-        });
-    });
-    /* eslint-disable unused-imports/no-unused-vars-ts */
-    function typeTests() {
-        const creator = actionCreator(actionType);
-        // @ts-ignore
-        let a = creator.type;
-        // $FlowExpectError
-        a = creator.type;
-        const action = creator(payload);
-        a = action.payload.a;
-        // $FlowExpectError
-        a = action.payload.a;
-        a = action.payload;
-    }
-    /* eslint-enable unused-imports/no-unused-vars-ts */
-});

package/dist/utils/redux/actionReducersBundle.js

@@ -1,18 +0,0 @@
-import mapValues from 'lodash-es/mapValues';
-const actionReducersBundle = (ctx) => (reducers) => {
-    const actions = mapValues(reducers, (_, actionType) => {
-        return (payload) => ({ type: actionType, payload });
-    });
-    const reducer = (prevState, action) => {
-        const { type } = action;
-        const innerReducer = reducers[type];
-        if (!innerReducer) {
-            ctx.logger.error(`Unkown action type '${type}'`);
-            return prevState;
-        }
-        const newState = innerReducer(prevState, action);
-        return newState;
-    };
-    return { actions, reducer };
-};
-export default actionReducersBundle;

package/dist/utils/redux/atomFromReduxStore.js

@@ -1,11 +0,0 @@
-import { Atom } from '@tomorrowevening/theatre-dataverse';
-export default function atomFromReduxStore(store) {
-    let lastState = store.getState();
-    const a = new Atom(lastState);
-    store.subscribe(() => {
-        const newState = store.getState();
-        a.set(newState);
-        lastState = newState;
-    });
-    return a;
-}

package/dist/utils/redux/configureStore.js

@@ -1,18 +0,0 @@
-import identity from 'lodash-es/identity';
-import { compose, createStore } from 'redux';
-export default function configureStore(conf) {
-    // const middlewares: $FixMe[] = []
-    const enhancers = [];
-    if (process.env.NODE_ENV !== 'production') {
-        const devtoolsEnhancer = process.env.NODE_ENV !== 'production' &&
-            typeof window === 'object' &&
-            window.__REDUX_DEVTOOLS_EXTENSION__
-            ? window.__REDUX_DEVTOOLS_EXTENSION__(conf.devtoolsOptions)
-            : identity;
-        enhancers.push(devtoolsEnhancer);
-    }
-    // enhancers.unshift(applyMiddleware(...middlewares))
-    const enhancer = compose(...enhancers);
-    const store = createStore(conf.rootReducer, undefined, enhancer);
-    return store;
-}

package/dist/utils/redux/pointerFriendlySelector.js

@@ -1,8 +0,0 @@
-/**
- * Takes a selector and returns a new selector that supports
- * both normal values and pointers
- */
-const pointerFriendlySelector = (fn) => {
-    return fn;
-};
-export default pointerFriendlySelector;

package/dist/utils/redux/withHistory/withBatchActions.js

@@ -1,13 +0,0 @@
-import actionCreator from '@tomorrowevening/theatre-studio/utils/redux/actionCreator';
-export const batchedAction = actionCreator('@@batched', (actions) => actions);
-const withBatchedActions = (reducer) => {
-    return (prevState, action) => {
-        if (batchedAction.is(action)) {
-            return action.payload.reduce((stateSoFar, a) => reducer(stateSoFar, a), prevState);
-        }
-        else {
-            return reducer(prevState, action);
-        }
-    };
-};
-export default withBatchedActions;

package/dist/utils/redux/withHistory/withHistory.js

@@ -1,157 +0,0 @@
-import actionCreator from '@tomorrowevening/theatre-studio/utils/redux/actionCreator';
-import jiff from 'jiff';
-import patch from 'json-touch-patch';
-import last from 'lodash-es/last';
-import { v4 as makeUUID } from 'uuid';
-export const historicActions = {
-    /**
-     * This action causes the reducer to replace the history it has tracked,
-     * with a new history. This is useful for persisting and re-hydrating the
-     * entire history to/from a persistent storage.
-     */
-    replaceHistory: actionCreator('@history/replaceHistory'),
-    /**
-     * This action causes the reducer to start the history from scratch. This is useful
-     * for testing and development where you want to explicitly provide a state to the
-     * store.
-     */
-    startHistoryFromScratch: actionCreator('@history/startHistoryFromScratch'),
-    undo: actionCreator('@history/undo'),
-    redo: actionCreator('@history/redo'),
-};
-export const isHistoricAction = (a) => {
-    return Object.entries(historicActions).some(([, actionCreator]) => actionCreator.is(a));
-};
-//
-const unknownAction = { type: '@history/unknownAction', payload: '' };
-const defaultConfig = {
-    maxNumberOfCommits: 100,
-};
-export const withHistory = (innerReducer, config = defaultConfig) => {
-    const cachedEmptyHistory = createEmptyHistory(innerReducer(undefined, unknownAction));
-    return function historicReducer(state, action) {
-        if (historicActions.startHistoryFromScratch.is(action)) {
-            return createEmptyHistory(innerReducer(undefined, action.payload));
-        }
-        else if (historicActions.replaceHistory.is(action)) {
-            return action.payload;
-        }
-        else {
-            if (historicActions.undo.is(action)) {
-                return state ? undo(state) : cachedEmptyHistory;
-            }
-            else if (historicActions.redo.is(action)) {
-                return state ? redo(state) : cachedEmptyHistory;
-            }
-            else {
-                if (state) {
-                    return pushCommit(state, innerReducer(state.innerState, action), config);
-                }
-                else {
-                    return createEmptyHistory(innerReducer(undefined, action));
-                }
-            }
-        }
-    };
-};
-function createEmptyHistory(innerState) {
-    return {
-        currentCommitHash: undefined,
-        commitsByHash: {},
-        listOfCommitHashes: [],
-        innerState: innerState,
-    };
-}
-function pushCommit(prevHistory, newInnerState, config) {
-    if (newInnerState === prevHistory.innerState)
-        return prevHistory;
-    const commit = createCommit(prevHistory.innerState, newInnerState);
-    if (commit.forwardDiff.length === 0) {
-        return prevHistory;
-    }
-    const prevLastCommitHash = last(prevHistory.listOfCommitHashes);
-    const newHistory = {
-        currentCommitHash: commit.hash,
-        commitsByHash: { ...prevHistory.commitsByHash },
-        listOfCommitHashes: [...prevHistory.listOfCommitHashes],
-        innerState: newInnerState,
-    };
-    /*
-     * If we have undo-ed a few commits, and are now committing st which means we should discard
-     * the re-doable commits
-     * History: C C C C C C
-     *              ^ <- currentCommitHash
-     */
-    if (prevHistory.currentCommitHash !== prevLastCommitHash) {
-        const indexOfCurrentCommitHash = prevHistory.listOfCommitHashes.findIndex((v) => v === prevHistory.currentCommitHash);
-        const listOfCommitHashesToDiscard = prevHistory.listOfCommitHashes.slice(indexOfCurrentCommitHash + 1);
-        listOfCommitHashesToDiscard.forEach((hash) => {
-            delete newHistory.commitsByHash[hash];
-        });
-        newHistory.listOfCommitHashes.splice(indexOfCurrentCommitHash + 1, newHistory.listOfCommitHashes.length);
-    }
-    newHistory.listOfCommitHashes.push(commit.hash);
-    newHistory.commitsByHash[commit.hash] = commit;
-    if (newHistory.listOfCommitHashes.length > config.maxNumberOfCommits) {
-        const numberOfCommitsToDiscard = newHistory.listOfCommitHashes.length - config.maxNumberOfCommits;
-        const listOfCommitHashesToDiscard = newHistory.listOfCommitHashes.slice(0, numberOfCommitsToDiscard);
-        listOfCommitHashesToDiscard.forEach((hash) => {
-            delete newHistory.commitsByHash[hash];
-        });
-        newHistory.listOfCommitHashes.splice(0, numberOfCommitsToDiscard);
-    }
-    return newHistory;
-}
-function createCommit(oldSnapshot, newSnapshot) {
-    const forwardDiff = jiff.diff(oldSnapshot, newSnapshot, { invertible: false });
-    const backwardDiff = jiff.diff(newSnapshot, oldSnapshot, { invertible: false });
-    const timestamp = Date.now();
-    const commitHash = makeUUID();
-    const commit = {
-        forwardDiff,
-        backwardDiff,
-        timestamp,
-        hash: commitHash,
-    };
-    return commit;
-}
-function undo(prevHistory) {
-    if (prevHistory.currentCommitHash === undefined) {
-        return prevHistory;
-    }
-    const indexOfCurrentCommitHash = prevHistory.listOfCommitHashes.findIndex((v) => v === prevHistory.currentCommitHash);
-    if (indexOfCurrentCommitHash === -1) {
-        throw new Error('This should never happen');
-    }
-    const currentCommit = prevHistory.commitsByHash[prevHistory.currentCommitHash];
-    const newInnerState = patch(prevHistory.innerState, currentCommit.backwardDiff);
-    const indexOfNewCommitHash = indexOfCurrentCommitHash - 1;
-    const newCommitHash = indexOfNewCommitHash === -1
-        ? undefined
-        : prevHistory.listOfCommitHashes[indexOfNewCommitHash];
-    const newHistory = {
-        ...prevHistory,
-        currentCommitHash: newCommitHash,
-        innerState: newInnerState,
-    };
-    return newHistory;
-}
-function redo(prevHistory) {
-    if (prevHistory.listOfCommitHashes.length === 0) {
-        return prevHistory;
-    }
-    const indexOfCurrentCommitHash = prevHistory.listOfCommitHashes.findIndex((v) => v === prevHistory.currentCommitHash);
-    if (indexOfCurrentCommitHash === prevHistory.listOfCommitHashes.length - 1) {
-        return prevHistory;
-    }
-    const indexOfNewCommitHash = indexOfCurrentCommitHash + 1;
-    const newCommitHash = prevHistory.listOfCommitHashes[indexOfNewCommitHash];
-    const currentCommit = prevHistory.commitsByHash[newCommitHash];
-    const newInnerState = patch(prevHistory.innerState, currentCommit.forwardDiff);
-    const newHistory = {
-        ...prevHistory,
-        currentCommitHash: newCommitHash,
-        innerState: newInnerState,
-    };
-    return newHistory;
-}

package/dist/utils/renderInPortalInContext.js

@@ -1,38 +0,0 @@
-import { Atom } from '@tomorrowevening/theatre-dataverse';
-import { useVal } from '@tomorrowevening/theatre-react';
-import React from 'react';
-import { createPortal } from 'react-dom';
-const theAtom = new Atom({
-    set: {},
-    byId: {},
-});
-let lastId = 1;
-export const getMounter = () => {
-    const id = lastId++;
-    function mountOrRender(comp, props, portalNode) {
-        theAtom.reduce((s) => {
-            return {
-                byId: { ...s.byId, [id]: { comp, props, portalNode } },
-                set: { ...s.set, [id]: true },
-            };
-        });
-    }
-    function unmount() {
-        theAtom.reduce((s) => {
-            const set = { ...s.set };
-            const byId = { ...s.byId };
-            delete set[id];
-            return { byId, set };
-        });
-    }
-    return { mountOrRender, unmount };
-};
-export const MountAll = () => {
-    const ids = Object.keys(useVal(theAtom.pointer.set));
-    return (React.createElement(React.Fragment, null, ids.map((id) => (React.createElement(Mount, { key: 'id-' + id, id: id })))));
-};
-const Mount = ({ id }) => {
-    const { comp, portalNode, props } = useVal(theAtom.pointer.byId[id]);
-    const Comp = comp;
-    return createPortal(React.createElement(Comp, { ...props }), portalNode);
-};

package/dist/utils/selectClosestHTMLAncestor.js

@@ -1,13 +0,0 @@
-/**
- * Traverse upwards from the current element to find the first element that matches the selector.
- */
-export function selectClosestHTMLAncestor(start, selector) {
-    if (start == null)
-        return null;
-    if (start instanceof Element && start.matches(selector)) {
-        return start;
-    }
-    else {
-        return selectClosestHTMLAncestor(start.parentElement, selector);
-    }
-}

package/dist/utils/tightJsonStringify.js

@@ -1,27 +0,0 @@
-/**
- * Stringifies an object in a developer-readable, command line friendly way
- * (not too spaced out, but with enough whitespace to be readable).
- *
- * e.g.
- * ```ts
- * tightJsonStringify({a:1, b: {c: [1, 2, {d: 4}], e: 8}})
- * ```
- * becomes
- * ```json
- * { "a": 1,
- *   "b": {
- *     "c": [
- *       1,
- *       2,
- *       { "d": 4 } ],
- *     "e": 8 } }
- * ```
- *
- * Also, see the examples in [`./tightJsonStringify.test.ts`](./tightJsonStringify.test.ts)
- */
-export function tightJsonStringify(obj, replacer) {
-    return JSON.stringify(obj, replacer, 2)
-        .replace(/^([\{\[])\n (\s+)/, '$1$2')
-        .replace(/(\n[ ]+[\{\[])\n\s+/g, '$1 ')
-        .replace(/\n\s*([\]\}])/g, ' $1');
-}

package/dist/utils/tightJsonStringify.test.js

@@ -1,25 +0,0 @@
-import { tightJsonStringify } from './tightJsonStringify';
-describe('tightJsonStringify', () => {
-    it('matches a series of expectations', () => {
-        expect(tightJsonStringify({ a: 1, b: 2, c: { y: 4, z: 745 } }))
-            .toMatchInlineSnapshot(`
-      "{ "a": 1,
-        "b": 2,
-        "c": {
-          "y": 4,
-          "z": 745 } }"
-    `);
-        expect(tightJsonStringify(true)).toMatchInlineSnapshot(`"true"`);
-        expect(tightJsonStringify('Already a string')).toMatchInlineSnapshot(`""Already a string""`);
-        expect(tightJsonStringify({ a: 1, b: { c: [1, 2, { d: 4 }], e: 8 } }))
-            .toMatchInlineSnapshot(`
-      "{ "a": 1,
-        "b": {
-          "c": [
-            1,
-            2,
-            { "d": 4 } ],
-          "e": 8 } }"
-    `);
-    });
-});

package/dist/utils/useRefAndState.js

@@ -1,32 +0,0 @@
-import { useMemo, useState } from 'react';
-/**
- * Combines useRef() and useState().
- *
- * @example
- * Usage:
- * ```ts
- * const [ref, val] = useRefAndState<HTMLDivElement | null>(null)
- *
- * useEffect(() => {
- *   val.addEventListener(...)
- * }, [val])
- *
- * return <div ref={ref}></div>
- * ```
- */
-export default function useRefAndState(initialValue) {
-    const ref = useMemo(() => {
-        let current = initialValue;
-        return {
-            get current() {
-                return current;
-            },
-            set current(v) {
-                current = v;
-                setState(v);
-            },
-        };
-    }, []);
-    const [state, setState] = useState(() => initialValue);
-    return [ref, state];
-}