@tomorrowevening/theatre-studio 1.0.4 → 1.0.5

package/dist/utils/mousePositionD.js

@@ -0,0 +1,18 @@
+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.d.ts

@@ -0,0 +1,49 @@
+import type { $IntentionalAny } from '@tomorrowevening/theatre-shared/utils/types';
+interface Transformer<Input extends $IntentionalAny, Output extends $IntentionalAny> {
+    (input: Input): Output;
+}
+type SubString<T> = T extends string ? (string extends T ? never : T) : never;
+interface ActionCreatorCreator {
+    <ActionType extends string, Payload, Input>(actionType: SubString<ActionType>, transformer: Transformer<Input, Payload>): {
+        (input: Input): {
+            type: SubString<ActionType>;
+            payload: Payload;
+        };
+        type: SubString<ActionType>;
+        ActionType: {
+            type: SubString<ActionType>;
+            payload: Payload;
+        };
+        is: (o: $IntentionalAny) => o is {
+            type: SubString<ActionType>;
+            payload: Payload;
+        };
+    };
+    <ActionType extends string>(actionType: SubString<ActionType>): {
+        <Payload>(payload: Payload): {
+            type: SubString<ActionType>;
+            payload: Payload;
+        };
+        (): {
+            type: SubString<ActionType>;
+            payload: void;
+        };
+        type: SubString<ActionType>;
+        ActionType: {
+            type: SubString<ActionType>;
+            payload: unknown;
+        };
+        is: (o: unknown) => o is {
+            type: SubString<ActionType>;
+            payload: unknown;
+        };
+    };
+}
+/**
+ * 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.
+ */
+declare const actionCreator: ActionCreatorCreator;
+export default actionCreator;
+//# sourceMappingURL=actionCreator.d.ts.map

package/dist/utils/redux/actionCreator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionCreator.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/utils/redux/actionCreator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,6CAA6C,CAAA;AAMhF,UAAU,WAAW,CACnB,KAAK,SAAS,eAAe,EAC7B,MAAM,SAAS,eAAe;IAE9B,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAA;CACvB;AAED,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,CAAC,MAAM,SAAS,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,GAAG,KAAK,CAAA;AAE7E,UAAU,oBAAoB;IAC5B,CAAC,UAAU,SAAS,MAAM,EAAE,OAAO,EAAE,KAAK,EACxC,UAAU,EAAE,SAAS,CAAC,UAAU,CAAC,EACjC,WAAW,EAAE,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,GACvC;QACD,CAAC,KAAK,EAAE,KAAK,GAAG;YAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;YAAC,OAAO,EAAE,OAAO,CAAA;SAAC,CAAA;QAC/D,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,CAAA;QAC3B,UAAU,EAAE;YAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;YAAC,OAAO,EAAE,OAAO,CAAA;SAAC,CAAA;QAC3D,EAAE,EAAE,CACF,CAAC,EAAE,eAAe,KACf,CAAC,IAAI;YAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;YAAC,OAAO,EAAE,OAAO,CAAA;SAAC,CAAA;KAC1D,CAAA;IAED,CAAC,UAAU,SAAS,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG;QAC9D,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG;YAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;YAAC,OAAO,EAAE,OAAO,CAAA;SAAC,CAAA;QAC5E,IAAI;YAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;YAAC,OAAO,EAAE,IAAI,CAAA;SAAC,CAAA;QAChD,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,CAAA;QAC3B,UAAU,EAAE;YAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;YAAC,OAAO,EAAE,OAAO,CAAA;SAAC,CAAA;QAC3D,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI;YAAC,IAAI,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;YAAC,OAAO,EAAE,OAAO,CAAA;SAAC,CAAA;KACzE,CAAA;CACF;AAED;;;;GAIG;AACH,QAAA,MAAM,aAAa,EAAE,oBAapB,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/utils/redux/actionCreator.js

@@ -0,0 +1,15 @@
+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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=actionCreator.test.d.ts.map

package/dist/utils/redux/actionCreator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionCreator.test.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/utils/redux/actionCreator.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,35 @@
+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.d.ts

@@ -0,0 +1,18 @@
+import type { IUtilContext } from '@tomorrowevening/theatre-shared/logger';
+import type { $IntentionalAny, GenericAction } from '@tomorrowevening/theatre-shared/utils/types';
+/**
+ * [This is why you use twitter](https://twitter.com/ae_play/status/1323597147758043137)
+ */
+export type PayloadTypeOfReducer<Fn extends (s: $IntentionalAny, action: {
+    type: string;
+    payload: $IntentionalAny;
+}) => $IntentionalAny> = Parameters<Fn>[1]['payload'];
+declare const actionReducersBundle: <State>(ctx: IUtilContext) => <Reducers extends Record<string, (s: State, action: $IntentionalAny) => void>>(reducers: Reducers) => {
+    actions: { [K in keyof Reducers]: (payload: PayloadTypeOfReducer<Reducers[K]>) => {
+        type: K;
+        payload: PayloadTypeOfReducer<Reducers[K]>;
+    }; };
+    reducer: (prevState: State, action: GenericAction) => State;
+};
+export default actionReducersBundle;
+//# sourceMappingURL=actionReducersBundle.d.ts.map

package/dist/utils/redux/actionReducersBundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionReducersBundle.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/utils/redux/actionReducersBundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,wCAAwC,CAAA;AACxE,OAAO,KAAK,EAAC,eAAe,EAAE,aAAa,EAAC,MAAM,6CAA6C,CAAA;AAG/F;;GAEG;AACH,MAAM,MAAM,oBAAoB,CAC9B,EAAE,SAAS,CACT,CAAC,EAAE,eAAe,EAClB,MAAM,EAAE;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAC,KAC7C,eAAe,IAClB,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;AAEhC,QAAA,MAAM,oBAAoB,eACX,YAAY,yDAIF,eAAe,KAAK,IAAI;;;;;wCAgBF,aAAa;CAazD,CAAA;AAEH,eAAe,oBAAoB,CAAA"}

package/dist/utils/redux/actionReducersBundle.js

@@ -0,0 +1,18 @@
+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.d.ts

@@ -0,0 +1,4 @@
+import { Atom } from '@tomorrowevening/theatre-dataverse';
+import type { Store } from 'redux';
+export default function atomFromReduxStore<State>(store: Store<State>): Atom<State>;
+//# sourceMappingURL=atomFromReduxStore.d.ts.map

package/dist/utils/redux/atomFromReduxStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomFromReduxStore.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/utils/redux/atomFromReduxStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,oCAAoC,CAAA;AACvD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,OAAO,CAAA;AAEhC,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,KAAK,EAC9C,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,GAClB,IAAI,CAAC,KAAK,CAAC,CAWb"}

package/dist/utils/redux/atomFromReduxStore.js

@@ -0,0 +1,11 @@
+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.d.ts

@@ -0,0 +1,9 @@
+import type { $FixMe, ReduxReducer } from '@tomorrowevening/theatre-shared/utils/types';
+import type { Store } from 'redux';
+interface Conf<State extends {}> {
+    rootReducer: ReduxReducer<State>;
+    devtoolsOptions?: $FixMe;
+}
+export default function configureStore<State extends {}>(conf: Conf<State>): Store<State>;
+export {};
+//# sourceMappingURL=configureStore.d.ts.map

package/dist/utils/redux/configureStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configureStore.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/utils/redux/configureStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAEN,YAAY,EACb,MAAM,6CAA6C,CAAA;AAEpD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,OAAO,CAAA;AAGhC,UAAU,IAAI,CAAC,KAAK,SAAS,EAAE;IAC7B,WAAW,EAAE,YAAY,CAAC,KAAK,CAAC,CAAA;IAChC,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,KAAK,SAAS,EAAE,EACrD,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,GAChB,KAAK,CAAC,KAAK,CAAC,CA0Bd"}

package/dist/utils/redux/configureStore.js

@@ -0,0 +1,18 @@
+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.d.ts

@@ -0,0 +1,10 @@
+import type { $IntentionalAny } from '@tomorrowevening/theatre-shared/utils/types';
+import type { Pointer } from '@tomorrowevening/theatre-dataverse';
+type PointerFriendlySelector<S, R, Args extends $IntentionalAny[]> = <GivenState extends S | Pointer<S>>(state: GivenState, ...args: Args) => GivenState extends Pointer<S> ? Pointer<R> : GivenState extends S ? R : never;
+/**
+ * Takes a selector and returns a new selector that supports
+ * both normal values and pointers
+ */
+declare const pointerFriendlySelector: <S, R, Args extends any[]>(fn: (s: S, ...args: Args) => R) => PointerFriendlySelector<S, R, Args>;
+export default pointerFriendlySelector;
+//# sourceMappingURL=pointerFriendlySelector.d.ts.map

package/dist/utils/redux/pointerFriendlySelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointerFriendlySelector.d.ts","sourceRoot":"","sources":["../../../../../../studio/src/utils/redux/pointerFriendlySelector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,6CAA6C,CAAA;AAChF,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,oCAAoC,CAAA;AAE/D,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,SAAS,eAAe,EAAE,IAAI,CACnE,UAAU,SAAS,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAEjC,KAAK,EAAE,UAAU,EACjB,GAAG,IAAI,EAAE,IAAI,KACV,UAAU,SAAS,OAAO,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,CAAC,CAAC,GACV,UAAU,SAAS,CAAC,GACpB,CAAC,GACD,KAAK,CAAA;AAET;;;GAGG;AACH,QAAA,MAAM,uBAAuB,mGAI5B,CAAA;AAED,eAAe,uBAAuB,CAAA"}

package/dist/utils/redux/pointerFriendlySelector.js

@@ -0,0 +1,8 @@
+/**
+ * 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.d.ts

@@ -0,0 +1,19 @@
+import type { GenericAction, ReduxReducer } from '@tomorrowevening/theatre-shared/utils/types';
+export declare const batchedAction: {
+    (input: GenericAction[]): {
+        type: "@@batched";
+        payload: GenericAction[];
+    };
+    type: "@@batched";
+    ActionType: {
+        type: "@@batched";
+        payload: GenericAction[];
+    };
+    is: (o: any) => o is {
+        type: "@@batched";
+        payload: GenericAction[];
+    };
+};
+declare const withBatchedActions: <S extends {}>(reducer: ReduxReducer<S>) => ReduxReducer<S>;
+export default withBatchedActions;
+//# sourceMappingURL=withBatchActions.d.ts.map

package/dist/utils/redux/withHistory/withBatchActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withBatchActions.d.ts","sourceRoot":"","sources":["../../../../../../../studio/src/utils/redux/withHistory/withBatchActions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,aAAa,EACb,YAAY,EACb,MAAM,6CAA6C,CAAA;AAEpD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;CAGzB,CAAA;AAED,QAAA,MAAM,kBAAkB,6DAcvB,CAAA;AAED,eAAe,kBAAkB,CAAA"}

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

@@ -0,0 +1,13 @@
+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.d.ts

@@ -0,0 +1,127 @@
+import type { ReduxReducer } from '@tomorrowevening/theatre-shared/utils/types';
+export declare 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: {
+        <Payload>(payload: Payload): {
+            type: "@history/replaceHistory";
+            payload: Payload;
+        };
+        (): {
+            type: "@history/replaceHistory";
+            payload: void;
+        };
+        type: "@history/replaceHistory";
+        ActionType: {
+            type: "@history/replaceHistory";
+            payload: unknown;
+        };
+        is: (o: unknown) => o is {
+            type: "@history/replaceHistory";
+            payload: unknown;
+        };
+    };
+    /**
+     * 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: {
+        <Payload_1>(payload: Payload_1): {
+            type: "@history/startHistoryFromScratch";
+            payload: Payload_1;
+        };
+        (): {
+            type: "@history/startHistoryFromScratch";
+            payload: void;
+        };
+        type: "@history/startHistoryFromScratch";
+        ActionType: {
+            type: "@history/startHistoryFromScratch";
+            payload: unknown;
+        };
+        is: (o: unknown) => o is {
+            type: "@history/startHistoryFromScratch";
+            payload: unknown;
+        };
+    };
+    undo: {
+        <Payload_2>(payload: Payload_2): {
+            type: "@history/undo";
+            payload: Payload_2;
+        };
+        (): {
+            type: "@history/undo";
+            payload: void;
+        };
+        type: "@history/undo";
+        ActionType: {
+            type: "@history/undo";
+            payload: unknown;
+        };
+        is: (o: unknown) => o is {
+            type: "@history/undo";
+            payload: unknown;
+        };
+    };
+    redo: {
+        <Payload_3>(payload: Payload_3): {
+            type: "@history/redo";
+            payload: Payload_3;
+        };
+        (): {
+            type: "@history/redo";
+            payload: void;
+        };
+        type: "@history/redo";
+        ActionType: {
+            type: "@history/redo";
+            payload: unknown;
+        };
+        is: (o: unknown) => o is {
+            type: "@history/redo";
+            payload: unknown;
+        };
+    };
+};
+export type HistoricAction = typeof historicActions[keyof typeof historicActions]['ActionType'];
+export declare const isHistoricAction: (a: unknown) => a is {
+    type: "@history/replaceHistory";
+    payload: unknown;
+} | {
+    type: "@history/startHistoryFromScratch";
+    payload: unknown;
+} | {
+    type: "@history/undo";
+    payload: unknown;
+} | {
+    type: "@history/redo";
+    payload: unknown;
+};
+type JSONPatchOp = unknown;
+export type JSONPatchDiff = JSONPatchOp[];
+type CommitHash = string;
+interface Commit {
+    hash: CommitHash;
+    forwardDiff: JSONPatchOp[];
+    backwardDiff: JSONPatchOp[];
+    timestamp: number;
+}
+export interface IWithHistory<InnerState> {
+    innerState: InnerState;
+    /**
+     * If undefined, it means we've started the history from scratch.
+     */
+    currentCommitHash: CommitHash | undefined;
+    commitsByHash: Record<CommitHash, Commit>;
+    listOfCommitHashes: CommitHash[];
+}
+interface WithHistoryConfig {
+    maxNumberOfCommits: number;
+}
+export declare const withHistory: <InnerState extends {}>(innerReducer: ReduxReducer<InnerState>, config?: WithHistoryConfig) => ReduxReducer<IWithHistory<InnerState>>;
+export {};
+//# sourceMappingURL=withHistory.d.ts.map

package/dist/utils/redux/withHistory/withHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withHistory.d.ts","sourceRoot":"","sources":["../../../../../../../studio/src/utils/redux/withHistory/withHistory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,YAAY,EACb,MAAM,6CAA6C,CAAA;AAMpD,eAAO,MAAM,eAAe;IAC1B;;;;OAIG;;;;;;;;;;;;;;;;;;;;IAGH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKJ,CAAA;AAED,MAAM,MAAM,cAAc,GACxB,OAAO,eAAe,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC,YAAY,CAAC,CAAA;AAEpE,eAAO,MAAM,gBAAgB,MAAO,OAAO;;;;;;;;;;;;CAI1C,CAAA;AAKD,KAAK,WAAW,GAAG,OAAO,CAAA;AAC1B,MAAM,MAAM,aAAa,GAAG,WAAW,EAAE,CAAA;AAEzC,KAAK,UAAU,GAAG,MAAM,CAAA;AAExB,UAAU,MAAM;IACd,IAAI,EAAE,UAAU,CAAA;IAChB,WAAW,EAAE,WAAW,EAAE,CAAA;IAC1B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,YAAY,CAAC,UAAU;IACtC,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,iBAAiB,EAAE,UAAU,GAAG,SAAS,CAAA;IACzC,aAAa,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAA;IACzC,kBAAkB,EAAE,UAAU,EAAE,CAAA;CACjC;AAED,UAAU,iBAAiB;IACzB,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAMD,eAAO,MAAM,WAAW,2EAEd,iBAAiB,2CAkC1B,CAAA"}

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

@@ -0,0 +1,157 @@
+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.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export declare const getMounter: () => {
+    mountOrRender: <Props extends {}>(comp: React.ComponentType<Props>, props: Props, portalNode: HTMLElement) => void;
+    unmount: () => void;
+};
+export declare const MountAll: () => React.JSX.Element;
+//# sourceMappingURL=renderInPortalInContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderInPortalInContext.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/renderInPortalInContext.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAA;AAmBzB,eAAO,MAAM,UAAU;kGAKP,WAAW;;CAoB1B,CAAA;AAED,eAAO,MAAM,QAAQ,yBASpB,CAAA"}

package/dist/utils/renderInPortalInContext.js

@@ -0,0 +1,38 @@
+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.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Traverse upwards from the current element to find the first element that matches the selector.
+ */
+export declare function selectClosestHTMLAncestor(start: Element | Node | null, selector: string): Element | null;
+//# sourceMappingURL=selectClosestHTMLAncestor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectClosestHTMLAncestor.d.ts","sourceRoot":"","sources":["../../../../../studio/src/utils/selectClosestHTMLAncestor.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,EAC5B,QAAQ,EAAE,MAAM,GACf,OAAO,GAAG,IAAI,CAOhB"}