@riboseinc/paneron-registry-kit 2.2.58 → 2.2.60

package/dependencies-local/extension-kit/usePersistentStateReducer.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initialHook = exports.default = void 0;
+
+var _react = require("react");
+
+var _util = require("./util");
+
+/**
+ * An (abstract) hook that wraps React’s useReducer hook and handles storing and loading reducer state
+ * using provided functions.
+ */
+const DEFAULT_DEBOUNCE_DELAY = 200;
+const LOAD_STATE_ACTION_TYPE = 'loadedState';
+/**
+ * A reducer that persists each new state,
+ * and attempts to load persisted state when component is mounted.
+ *
+ * During the initial load, `initialized` is set to false.
+ *
+ * `storeState` is called on each change of state but debounced.
+ *
+ * NOTE: that state S cannot be an empty object,
+ * in such a case `initialState` will always be used.
+ */
+
+function usePersistentStateReducer(storeState, loadState, ...args) {
+  const [storageKey, storageDebounceMS, validator, reducer, initialState, initializer] = args;
+  const effectiveReducer = (0, _react.useCallback)(convertToPersistentReducer(reducer), [reducer]);
+  const [state, dispatch] = (0, _react.useReducer)(effectiveReducer, initialState, initializer !== null && initializer !== void 0 ? initializer : defaultInitializer);
+
+  if (!(0, _util.isObject)(initialState)) {
+    console.error("usePersistentStateReducer: initialState is not an object", initialState);
+    throw new Error("initialState is not an object");
+  }
+
+  const [initialized, setInitialized] = (0, _react.useState)(false);
+  (0, _react.useEffect)(() => {
+    setInitialized(false);
+    let cancelled = false;
+
+    (async () => {
+      const loadedState = await loadState(storageKey);
+
+      if (cancelled) {
+        return;
+      }
+
+      let effectiveState;
+
+      if (loadedState && (0, _util.isObject)(loadedState) && Object.keys(loadedState).length > 0) {
+        if (validator) {
+          if (validator(loadedState)) {
+            effectiveState = loadedState;
+          } else {
+            console.error("usePersistentStateReducer: Failed to validate loaded state for key", storageKey, loadedState, initialState);
+            effectiveState = initialState;
+          }
+        } else {
+          effectiveState = loadedState || initialState;
+        }
+      } else {
+        effectiveState = initialState;
+      }
+
+      dispatch({
+        type: LOAD_STATE_ACTION_TYPE,
+        payload: effectiveState
+      });
+      setInitialized(true);
+    })();
+
+    return function cleanUp() {
+      cancelled = true;
+    };
+  }, [dispatch, validator, loadState, initialState, storageKey]);
+  const debounceDelay = storageDebounceMS !== null && storageDebounceMS !== void 0 ? storageDebounceMS : DEFAULT_DEBOUNCE_DELAY;
+  (0, _react.useEffect)(() => {
+    if (initialized === true) {
+      let timeout = setTimeout(() => {
+        storeState(storageKey, state);
+      }, debounceDelay);
+      return () => clearTimeout(timeout);
+    }
+
+    return () => void 0;
+  }, [debounceDelay, storeState, storageKey, state]);
+  const effectiveState = state && Object.keys(state).length > 0 ? state : initialState;
+  return [effectiveState, dispatch, initialized];
+}
+
+var _default = usePersistentStateReducer;
+/**
+ * Creates a reducer that handles a special `loadedState` action,
+ * relevant to persistent state reducer, in addition to any other
+ * action handled by component-specific reducer function passed in.
+ */
+
+exports.default = _default;
+
+function convertToPersistentReducer(reducer) {
+  return function wrappedReducer(prevState, action) {
+    switch (action.type) {
+      case LOAD_STATE_ACTION_TYPE:
+        if ((0, _util.isObject)(action.payload)) {
+          // TODO: Why action type needs casting, not narrowed?
+          return { ...action.payload
+          };
+        } else {
+          console.error("usePersistentStateReducer: Loaded state is not an object", action === null || action === void 0 ? void 0 : action.payload);
+          throw new Error("Invalid state loaded: not an object");
+        }
+
+      default:
+        return reducer(prevState, action);
+    }
+  };
+}
+
+function defaultInitializer(s) {
+  return s;
+}
+
+async function noOpLoadState() {
+  return {};
+}
+
+const initialHook = (...args) => usePersistentStateReducer(() => void 0, noOpLoadState, ...args);
+
+exports.initialHook = initialHook;

package/dependencies-local/extension-kit/usePersistentStateReducer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePersistentStateReducer.js","sourceRoot":"","sources":["../src/usePersistentStateReducer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * An (abstract) hook that wraps React’s useReducer hook and handles storing and loading reducer state\n * using provided functions.\n */\n\nimport { useReducer, useEffect, useCallback, useState } from 'react';\nimport { isObject } from './util';\nimport type { Reducer, Dispatch } from 'react';\n\n\nconst DEFAULT_DEBOUNCE_DELAY = 200;\n\nconst LOAD_STATE_ACTION_TYPE = 'loadedState' as const;\n\n\nexport interface BaseAction {\n  type: string\n  payload?: any\n}\n\n\n/** Action issued when previously stored state is loaded. */\nexport interface LoadStateAction<S> extends BaseAction {\n  type: typeof LOAD_STATE_ACTION_TYPE\n\n  /** Loaded state. */\n  payload: S\n}\n\n\nexport type StateReducerHook<S, A extends BaseAction> =\n  (\n    reducer: Reducer<S, A>,\n    initialState: S,\n    initializer: ((initialState: S) => S) | null,\n  ) => [state: S, dispatch: Dispatch<A>];\n\nexport type PersistentStateReducerHook<S, A extends BaseAction> =\n  (\n    /** Each component should specify a unique storage key. */\n    storageKey: string,\n\n    /**\n     * Calls to store state will be debounced according to this delay\n     * in case state change too often.\n     */\n    storageDebounceMS?: number,\n\n    validateLoadedState?: (loadedValue: Partial<S> & any) => loadedValue is S,\n\n    ...args: Parameters<StateReducerHook<S, A>>\n  ) => [state: S, dispatch: Dispatch<A>, stateRecalled: boolean];\n\n\n\n/**\n * A reducer that persists each new state,\n * and attempts to load persisted state when component is mounted.\n *\n * During the initial load, `initialized` is set to false.\n *\n * `storeState` is called on each change of state but debounced.\n *\n * NOTE: that state S cannot be an empty object,\n * in such a case `initialState` will always be used.\n */\nfunction usePersistentStateReducer<S, A extends BaseAction>(\n  storeState: (key: string, newState: S) => void,\n  loadState: (key: string) => Promise<S | undefined>,\n  ...args: Parameters<PersistentStateReducerHook<S, A>>\n): [state: S, dispatch: Dispatch<A>, initialized: boolean] {\n  const [storageKey, storageDebounceMS, validator, reducer, initialState, initializer] = args;\n\n  const effectiveReducer = useCallback(convertToPersistentReducer(reducer), [reducer]);\n  const [state, dispatch] = useReducer(effectiveReducer, initialState, initializer ?? defaultInitializer)\n\n  if (!isObject(initialState)) {\n    console.error(\"usePersistentStateReducer: initialState is not an object\", initialState);\n    throw new Error(\"initialState is not an object\");\n  }\n\n  const [initialized, setInitialized] = useState(false);\n\n  useEffect(() => {\n    setInitialized(false);\n    let cancelled = false;\n    (async () => {\n      const loadedState = await loadState(storageKey);\n      if (cancelled) { return; }\n\n      let effectiveState: S | undefined;\n      if (loadedState && isObject(loadedState) && Object.keys(loadedState).length > 0) {\n        if (validator) {\n          if (validator(loadedState)) {\n            effectiveState = loadedState;\n          } else {\n            console.error(\"usePersistentStateReducer: Failed to validate loaded state for key\", storageKey, loadedState, initialState);\n            effectiveState = initialState;\n          }\n        } else {\n          effectiveState = loadedState || initialState;\n        }\n      } else {\n        effectiveState = initialState;\n      }\n      dispatch({\n        type: LOAD_STATE_ACTION_TYPE,\n        payload: effectiveState,\n      });\n      setInitialized(true);\n    })();\n    return function cleanUp() {\n      cancelled = true;\n    }\n  }, [dispatch, validator, loadState, initialState, storageKey]);\n\n\n  const debounceDelay = storageDebounceMS ?? DEFAULT_DEBOUNCE_DELAY;\n  useEffect(() => {\n    if (initialized === true) {\n      let timeout = setTimeout(() => {\n        storeState(storageKey, state);\n      }, debounceDelay);\n      return () => clearTimeout(timeout);\n    }\n    return () => void 0;\n  }, [debounceDelay, storeState, storageKey, state]);\n\n  const effectiveState = state && Object.keys(state).length > 0\n    ? state\n    : initialState;\n\n  return [effectiveState, dispatch, initialized];\n}\n\nexport default usePersistentStateReducer;\n\n\n\n/**\n * Creates a reducer that handles a special `loadedState` action,\n * relevant to persistent state reducer, in addition to any other\n * action handled by component-specific reducer function passed in.\n */\nfunction convertToPersistentReducer<S, A extends BaseAction>(\n  reducer: Reducer<S, A>,\n): Reducer<S, A | LoadStateAction<S>> {\n  return function wrappedReducer(prevState: S, action: A | LoadStateAction<S>) {\n    switch (action.type) {\n      case LOAD_STATE_ACTION_TYPE:\n        if (isObject((action as LoadStateAction<S>).payload)) {\n          // TODO: Why action type needs casting, not narrowed?\n          return { ...action.payload };\n        } else {\n          console.error(\"usePersistentStateReducer: Loaded state is not an object\", action?.payload);\n          throw new Error(\"Invalid state loaded: not an object\");\n        }\n      default:\n        return reducer(prevState, action as A);\n    }\n  }\n}\n\nfunction defaultInitializer<T>(s: T) { return s }\n\nasync function noOpLoadState() { return {} }\n\nexport const initialHook: PersistentStateReducerHook<any, any> =\n  (...args: Parameters<PersistentStateReducerHook<any, any>>) =>\n    usePersistentStateReducer(() => void 0, noOpLoadState, ...args);\n"]}

package/dependencies-local/extension-kit/useTimeTravelingPersistentStateReducer.d.ts

@@ -0,0 +1,71 @@
+import type { Dispatch } from 'react';
+import type { BaseAction, PersistentStateReducerHook, StateReducerHook } from './usePersistentStateReducer';
+declare const UNDO_ACTION_TYPE: "undo";
+declare const REDO_ACTION_TYPE: "redo";
+declare const RESET_ACTION_TYPE: "reset";
+export interface UndoAction extends BaseAction {
+    type: typeof UNDO_ACTION_TYPE;
+}
+export interface RedoAction extends BaseAction {
+    type: typeof REDO_ACTION_TYPE;
+}
+export interface ResetAction extends BaseAction {
+    type: typeof RESET_ACTION_TYPE;
+}
+export declare type TimeTravelAction = UndoAction | RedoAction | ResetAction;
+interface Timeline<S> {
+    present: S;
+    /** States that led to present state. */
+    past: S[];
+    /**
+     * Undoing a state makes present state first future state,
+     * and last past state the present.
+     */
+    future: S[];
+}
+declare type TimeTravelingPersistentStateReducerHookParams<S, A extends BaseAction> = [
+    /** How far back to allow the state to be rewound. */
+    maxHistorySteps: number,
+    /** Persistent reducer hook iplementation to delegate to. */
+    usePersistentReducer: PersistentStateReducerHook<Timeline<S>, A | TimeTravelAction>,
+    /** Each component should specify a unique storage key. */
+    storageKey: string,
+    /**
+     * Calls to store state will be debounced according to this delay
+     * in case state change too often.
+     */
+    storageDebounceMS?: number,
+    validateLoadedState?: (loadedValue: any) => loadedValue is S,
+    ...stateReducerHookArgs: Parameters<StateReducerHook<S, A>>
+];
+export declare type TimeTravelingPersistentStateReducerHook<S, A extends BaseAction> = (...args: TimeTravelingPersistentStateReducerHookParams<S, A>) => TimeTravelingPersistentStateReducerInterface<S, A>;
+interface TimeTravelingPersistentStateReducerInterface<S, A extends BaseAction> {
+    /** Present state. */
+    state: S;
+    /** Supports actions by wrapped reduce, and time-traveling actions below. */
+    dispatch: Dispatch<A>;
+    /**
+     * Go to previous state in the timeline;
+     * present state will become next “future” state.
+     */
+    undo: () => void;
+    /** Makes next (if any) “future” state in the timeline present. */
+    redo: () => void;
+    /**
+     * Resetting rewinds the timeline back to the beginning.
+     * All states are future states.
+     * Redoing is still possible (in that sense it’s not a proper reset).
+     */
+    reset: () => void;
+    /** State change history. */
+    timeline: Timeline<S>;
+    /** Proxied from persistent reducer. */
+    initialized: boolean;
+}
+/**
+ * Supports persistent state reducer features,
+ * but also offers time travel through undo/redo/reset actions.
+ */
+export declare function useTimeTravelingPersistentStateReducer<S, A extends BaseAction>(...args: TimeTravelingPersistentStateReducerHookParams<S, A>): TimeTravelingPersistentStateReducerInterface<S, A>;
+export default useTimeTravelingPersistentStateReducer;
+export declare const initialHook: TimeTravelingPersistentStateReducerHook<any, any>;

package/dependencies-local/extension-kit/useTimeTravelingPersistentStateReducer.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTimeTravelingPersistentStateReducer = useTimeTravelingPersistentStateReducer;
+exports.initialHook = exports.default = void 0;
+
+var _immer = _interopRequireDefault(require("immer"));
+
+var _react = require("react");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const UNDO_ACTION_TYPE = 'undo';
+const REDO_ACTION_TYPE = 'redo';
+const RESET_ACTION_TYPE = 'reset';
+/**
+ * Supports persistent state reducer features,
+ * but also offers time travel through undo/redo/reset actions.
+ */
+
+function useTimeTravelingPersistentStateReducer(...args) {
+  const [maxHistorySteps, usePersistentReducer, storageKey, storageDebounceMS,, reducer, initialState, initializer] = args;
+  const initialTimeline = (0, _react.useMemo)(() => ({
+    past: [],
+    present: initializer ? initializer(initialState) : initialState,
+    future: []
+  }), [initialState, initializer]);
+  const proxiedReducer = (0, _react.useCallback)((tl, action) => {
+    switch (action.type) {
+      case UNDO_ACTION_TYPE:
+        return _doUndo(tl);
+
+      case REDO_ACTION_TYPE:
+        return _doRedo(tl);
+
+      case RESET_ACTION_TYPE:
+        return _doReset(tl);
+
+      default:
+        const newState = (0, _immer.default)(tl.present, draft => reducer(draft, action));
+        return _addNewPresent(tl, newState, maxHistorySteps);
+    }
+  }, [reducer, maxHistorySteps]);
+  const [_timeline, _dispatch, _initialized] = usePersistentReducer(storageKey, storageDebounceMS, undefined, proxiedReducer, initialTimeline, null);
+  return {
+    state: _timeline.present,
+    timeline: _timeline,
+    dispatch: _dispatch,
+    undo: () => _dispatch({
+      type: UNDO_ACTION_TYPE
+    }),
+    redo: () => _dispatch({
+      type: REDO_ACTION_TYPE
+    }),
+    reset: () => _dispatch({
+      type: RESET_ACTION_TYPE
+    }),
+    initialized: _initialized
+  };
+}
+
+function _addNewPresent(timeline, newPresent, maxHistoryEntries) {
+  return (0, _immer.default)(timeline, draft => {
+    draft.past.push(draft.present); // TODO: apply maxHistoryEntries constraint here
+
+    draft.present = newPresent;
+    draft.future = [];
+  });
+}
+
+function _doUndo(timeline) {
+  return (0, _immer.default)(timeline, draft => {
+    if (!draft.past.length) return;
+    const newPresent = draft.past.pop(); // TODO: validate restored past; abort and wipe further past if invalid.
+
+    draft.future.unshift(draft.present);
+    draft.present = newPresent;
+  });
+}
+
+function _doRedo(timeline) {
+  return (0, _immer.default)(timeline, draft => {
+    if (!draft.future.length) return;
+    const newPresent = draft.future.shift();
+    draft.past.push(draft.present);
+    draft.present = newPresent;
+  });
+}
+
+function _doReset(timeline) {
+  return (0, _immer.default)(timeline, draft => {
+    if (!draft.past.length) return;
+    const newPresent = draft.past.shift();
+    draft.future = [...draft.past, draft.present, ...draft.future];
+    draft.present = newPresent;
+    draft.past = [];
+  });
+}
+
+var _default = useTimeTravelingPersistentStateReducer;
+exports.default = _default;
+
+const initialHook = (...args) => useTimeTravelingPersistentStateReducer(...args);
+
+exports.initialHook = initialHook;

package/dependencies-local/extension-kit/useTimeTravelingPersistentStateReducer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTimeTravelingPersistentStateReducer.js","sourceRoot":"","sources":["../src/useTimeTravelingPersistentStateReducer.ts"],"names":[],"mappings":"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","sourcesContent":["import produce, { type Draft } from 'immer';\nimport type { Dispatch } from 'react';\nimport { useMemo, useCallback } from 'react';\nimport type { BaseAction, PersistentStateReducerHook, StateReducerHook } from './usePersistentStateReducer';\n\n\nconst UNDO_ACTION_TYPE = 'undo' as const;\nconst REDO_ACTION_TYPE = 'redo' as const;\nconst RESET_ACTION_TYPE = 'reset' as const;\n\nexport interface UndoAction extends BaseAction {\n  type: typeof UNDO_ACTION_TYPE;\n}\n\nexport interface RedoAction extends BaseAction {\n  type: typeof REDO_ACTION_TYPE;\n}\n\nexport interface ResetAction extends BaseAction {\n  type: typeof RESET_ACTION_TYPE;\n}\n\nexport type TimeTravelAction = UndoAction | RedoAction | ResetAction;\n\ninterface Timeline<S> {\n  present: S;\n\n  /** States that led to present state. */\n  past: S[];\n\n  /**\n   * Undoing a state makes present state first future state,\n   * and last past state the present.\n   */\n  future: S[];\n}\n\ntype TimeTravelingPersistentStateReducerHookParams<S, A extends BaseAction> = [\n\n  /** How far back to allow the state to be rewound. */\n  maxHistorySteps: number,\n\n  /** Persistent reducer hook iplementation to delegate to. */\n  usePersistentReducer: PersistentStateReducerHook<Timeline<S>, A | TimeTravelAction>,\n\n  // These are duplicated from PersistentStateReducerHook\n\n  /** Each component should specify a unique storage key. */\n  storageKey: string,\n\n  /**\n   * Calls to store state will be debounced according to this delay\n   * in case state change too often.\n   */\n  storageDebounceMS?: number,\n\n  validateLoadedState?: (loadedValue: any) => loadedValue is S,\n\n  ...stateReducerHookArgs: Parameters<StateReducerHook<S, A>>\n];\n\nexport type TimeTravelingPersistentStateReducerHook<S, A extends BaseAction> =\n  (...args: TimeTravelingPersistentStateReducerHookParams<S, A>) =>\n    TimeTravelingPersistentStateReducerInterface<S, A>;\n\ninterface TimeTravelingPersistentStateReducerInterface<S, A extends BaseAction> {\n  /** Present state. */\n  state: S;\n\n  /** Supports actions by wrapped reduce, and time-traveling actions below. */\n  dispatch: Dispatch<A>;\n\n  /**\n   * Go to previous state in the timeline;\n   * present state will become next “future” state.\n   */\n  undo: () => void;\n\n  /** Makes next (if any) “future” state in the timeline present. */\n  redo: () => void;\n\n  /**\n   * Resetting rewinds the timeline back to the beginning.\n   * All states are future states.\n   * Redoing is still possible (in that sense it’s not a proper reset).\n   */\n  reset: () => void;\n\n  // TODO: Implenment “proper” reset that makes initial state present\n  // and also clears past and future.\n\n  /** State change history. */\n  timeline: Timeline<S>;\n\n  /** Proxied from persistent reducer. */\n  initialized: boolean;\n}\n\n/**\n * Supports persistent state reducer features,\n * but also offers time travel through undo/redo/reset actions.\n */\nexport function useTimeTravelingPersistentStateReducer<S, A extends BaseAction>(\n  ...args: TimeTravelingPersistentStateReducerHookParams<S, A>\n): TimeTravelingPersistentStateReducerInterface<S, A> {\n  const [maxHistorySteps, usePersistentReducer, storageKey, storageDebounceMS, , reducer, initialState, initializer] = args;\n\n  const initialTimeline: Timeline<S> = useMemo(() => ({\n    past: [],\n    present: initializer ? initializer(initialState) : initialState,\n    future: [],\n  }), [initialState, initializer]);\n\n  const proxiedReducer = useCallback((tl: Timeline<S>, action: A | TimeTravelAction): Timeline<S> => {\n    switch (action.type) {\n      case UNDO_ACTION_TYPE:\n        return _doUndo(tl);\n      case REDO_ACTION_TYPE:\n        return _doRedo(tl);\n      case RESET_ACTION_TYPE:\n        return _doReset(tl);\n      default:\n        const newState = produce(tl.present, (draft) => reducer(draft as S, action as A) as Draft<S>);\n        return _addNewPresent(tl, newState, maxHistorySteps);\n    }\n  }, [reducer, maxHistorySteps]);\n\n  const [_timeline, _dispatch, _initialized] = usePersistentReducer(\n    storageKey, storageDebounceMS, undefined, proxiedReducer, initialTimeline, null);\n\n  return {\n    state: _timeline.present,\n    timeline: _timeline,\n    dispatch: _dispatch,\n    undo: () => _dispatch({ type: UNDO_ACTION_TYPE }),\n    redo: () => _dispatch({ type: REDO_ACTION_TYPE }),\n    reset: () => _dispatch({ type: RESET_ACTION_TYPE }),\n    initialized: _initialized,\n  };\n}\n\nfunction _addNewPresent<S>(timeline: Timeline<S>, newPresent: S, maxHistoryEntries: number) {\n  return produce(timeline, draft => {\n    draft.past.push(draft.present);\n    // TODO: apply maxHistoryEntries constraint here\n    draft.present = newPresent as Draft<S>;\n    draft.future = [];\n  });\n}\n\nfunction _doUndo<S>(timeline: Timeline<S>) {\n  return produce(timeline, draft => {\n    if (!draft.past.length)\n      return;\n    const newPresent = draft.past.pop() as Draft<S>;\n    // TODO: validate restored past; abort and wipe further past if invalid.\n    draft.future.unshift(draft.present);\n    draft.present = newPresent;\n  });\n}\n\nfunction _doRedo<S>(timeline: Timeline<S>) {\n  return produce(timeline, draft => {\n    if (!draft.future.length)\n      return;\n    const newPresent = draft.future.shift();\n    draft.past.push(draft.present);\n    draft.present = newPresent as Draft<S>;\n  });\n}\n\nfunction _doReset<S>(timeline: Timeline<S>) {\n  return produce(timeline, draft => {\n    if (!draft.past.length)\n      return;\n    const newPresent = draft.past.shift();\n    draft.future = [...draft.past, draft.present, ...draft.future];\n    draft.present = newPresent as Draft<S>;\n    draft.past = [];\n  });\n}\n\nexport default useTimeTravelingPersistentStateReducer;\n\n\nexport const initialHook: TimeTravelingPersistentStateReducerHook<any, any> =\n  (...args: Parameters<TimeTravelingPersistentStateReducerHook<any, any>>) =>\n    useTimeTravelingPersistentStateReducer(...args);\n"]}

package/dependencies-local/extension-kit/util.d.ts

@@ -0,0 +1,37 @@
+import type { Progress } from './types/progress';
+export declare type Entries<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+export declare function stripLeadingSlash(fp: string): string;
+export declare function progressToValue(progress: Progress): number;
+export declare const encoder: TextEncoder;
+export declare const decoder: TextDecoder;
+export declare type OnlyJSON<T> = T extends string | number | boolean | null ? T : T extends Function ? never : T extends object ? {
+    [K in keyof T]: OnlyJSON<T[K]>;
+} : never;
+/**
+ * Normalizes object by ensuring its keys are sorted.
+ * May not be the most efficient way of doing so.
+ */
+export declare function normalizeObject<T extends Record<string, any>>(obj: T): T;
+export declare function toJSONPreservingUndefined(data: any, indentation?: number): string;
+/**
+ * NOTE: This is NOT a very fast implementation yet. Try to avoid.
+ */
+export declare function toJSONNormalized(val: any, indentation?: number): string;
+/**
+ * @deprecated use `toJSONNormalized()` instead.
+ */
+export declare const JSONStringifyNormalized: typeof toJSONNormalized;
+export declare function objectsHaveSameShape(l: any, r: any): boolean;
+/**
+ * Does the equivalent of `normalizeObject` on given object
+ * as well as any objects encountered within.
+ */
+export declare function normalizeObjectRecursively<T extends Record<string, any>>(obj: T, _seen?: null | WeakSet<any>): T;
+/**
+ * Returns true if given value is a regular object (‘hash’),
+ * excluding “special” objects like dates etc.
+ */
+export declare function isObject(val: unknown): val is Record<string, any>;
+export declare const BP4_RESET_CSS = "\n  body, html {\n    -webkit-font-smoothing: antialiased;\n    font-family: -apple-system, BlinkMacSystemFont, avenir next, avenir, segoe ui, helvetica neue, helvetica, Ubuntu, roboto, noto, arial, sans-serif;\n  }\n\n  .filter-popover .bp4-popover2-content {\n    border-radius: 0;\n  }\n  .bp4-overlay-backdrop.bp4-popover2-backdrop {\n    background: rgba(0, 0, 0, .5);\n  }\n\n  .bp4-tag.bp4-interactive {\n    cursor: default !important;\n  }\n  .bp4-tag-remove {\n    cursor: default !important;\n  }\n\n  .bp4-input {\n    /*\n     * \u201Cmiddle\u201D, specified by BP4, causes issues with inpout text <-> OL marker alignment.\n     * This seems to have no side-effects.\n     */\n    vertical-align: unset;\n  }\n  .bp4-input:read-only {\n    box-shadow: inset silver 1px -1px;\n    background: none;\n  }\n  .bp4-dark .bp4-input:read-only {\n    box-shadow: inset rgba(255, 255, 255, 0.2) 1px -1px;\n  }\n  .bp4-tree-node-caret {\n    cursor: default !important;\n  }\n\n  /* Why was it added? It breaks hover, definitely.\n    .bp4-tree-node-content:hover {\n      background: unset;\n    }\n  */\n\n  .bp4-html-select select {\n    cursor: default !important;\n  }\n\n  .bp4-button {\n    cursor: default !important;\n\n  }\n\n    .bp4-button:focus {\n      outline: none;\n    }\n\n  .bp4-tab {\n    cursor: default !important;\n  }\n\n  .bp4-menu-item {\n    cursor: default;\n  }\n\n    .bp4-menu-item, .bp4-menu .bp4-menu-item.bp4-disabled {\n      cursor: default !important;\n    }\n";

package/dependencies-local/extension-kit/util.js

@@ -0,0 +1,179 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stripLeadingSlash = stripLeadingSlash;
+exports.progressToValue = progressToValue;
+exports.normalizeObject = normalizeObject;
+exports.toJSONPreservingUndefined = toJSONPreservingUndefined;
+exports.toJSONNormalized = toJSONNormalized;
+exports.objectsHaveSameShape = objectsHaveSameShape;
+exports.normalizeObjectRecursively = normalizeObjectRecursively;
+exports.isObject = isObject;
+exports.BP4_RESET_CSS = exports.JSONStringifyNormalized = exports.decoder = exports.encoder = void 0;
+
+function stripLeadingSlash(fp) {
+  return fp.replace(/^\//, '');
+}
+
+function progressToValue(progress) {
+  return 1 / progress.total * progress.loaded;
+}
+
+const encoder = new TextEncoder();
+exports.encoder = encoder;
+const decoder = new TextDecoder('utf-8');
+/**
+ * Normalizes object by ensuring its keys are sorted.
+ * May not be the most efficient way of doing so.
+ */
+
+exports.decoder = decoder;
+
+function normalizeObject(obj) {
+  return Object.fromEntries(Object.entries(obj).sort());
+}
+
+function toJSONPreservingUndefined(data, indentation) {
+  return JSON.stringify(data || {}, (_, v) => v === undefined ? '__undefined' : v, indentation).replace(/\"__undefined\"/g, 'undefined');
+}
+/**
+ * NOTE: This is NOT a very fast implementation yet. Try to avoid.
+ */
+
+
+function toJSONNormalized(val, indentation) {
+  return toJSONPreservingUndefined(normalizeVal(val), indentation);
+}
+/**
+ * @deprecated use `toJSONNormalized()` instead.
+ */
+
+
+const JSONStringifyNormalized = toJSONNormalized;
+exports.JSONStringifyNormalized = JSONStringifyNormalized;
+
+function objectsHaveSameShape(l, r) {
+  return JSONStringifyNormalized(l) === JSONStringifyNormalized(r);
+}
+/**
+ * Does the equivalent of `normalizeObject` on given object
+ * as well as any objects encountered within.
+ */
+
+
+function normalizeObjectRecursively(obj, _seen = null) {
+  const seen = _seen !== null && _seen !== void 0 ? _seen : new WeakSet();
+
+  if (seen.has(obj)) {
+    return obj;
+  }
+
+  if (isObject(obj)) {
+    seen.add(obj);
+    const normalized = Object.fromEntries(Object.entries(obj).sort().map(([key, val]) => [key, normalizeVal(val, seen)]));
+    seen.delete(obj);
+    return normalized;
+  } else {
+    throw new Error(`Not an object: ${obj}`);
+  }
+}
+
+function normalizeVal(val, _seen = null) {
+  const seen = _seen !== null && _seen !== void 0 ? _seen : new WeakSet();
+
+  if (Array.isArray(val)) {
+    return val.map(v => isObject(v) ? normalizeObjectRecursively(v, seen) : v);
+  } else if (isObject(val)) {
+    return normalizeObjectRecursively(val, seen);
+  } else {
+    return val;
+  }
+}
+/**
+ * Returns true if given value is a regular object (‘hash’),
+ * excluding “special” objects like dates etc.
+ */
+
+
+function isObject(val) {
+  var _a;
+
+  return val !== null && typeof val === 'object' && !Array.isArray(val) && // val?.constructor === Object && // normal objects fail this one in extensions
+  ((_a = val === null || val === void 0 ? void 0 : val.toString) === null || _a === void 0 ? void 0 : _a.call(val)) === '[object Object]';
+} //function isArray(val: unknown): val is unknown[] {
+//  return val !== null && typeof val === 'object' && Array.isArray(val);
+//}
+
+
+const BP4_RESET_CSS = `
+  body, html {
+    -webkit-font-smoothing: antialiased;
+    font-family: -apple-system, BlinkMacSystemFont, avenir next, avenir, segoe ui, helvetica neue, helvetica, Ubuntu, roboto, noto, arial, sans-serif;
+  }
+
+  .filter-popover .bp4-popover2-content {
+    border-radius: 0;
+  }
+  .bp4-overlay-backdrop.bp4-popover2-backdrop {
+    background: rgba(0, 0, 0, .5);
+  }
+
+  .bp4-tag.bp4-interactive {
+    cursor: default !important;
+  }
+  .bp4-tag-remove {
+    cursor: default !important;
+  }
+
+  .bp4-input {
+    /*
+     * “middle”, specified by BP4, causes issues with inpout text <-> OL marker alignment.
+     * This seems to have no side-effects.
+     */
+    vertical-align: unset;
+  }
+  .bp4-input:read-only {
+    box-shadow: inset silver 1px -1px;
+    background: none;
+  }
+  .bp4-dark .bp4-input:read-only {
+    box-shadow: inset rgba(255, 255, 255, 0.2) 1px -1px;
+  }
+  .bp4-tree-node-caret {
+    cursor: default !important;
+  }
+
+  /* Why was it added? It breaks hover, definitely.
+    .bp4-tree-node-content:hover {
+      background: unset;
+    }
+  */
+
+  .bp4-html-select select {
+    cursor: default !important;
+  }
+
+  .bp4-button {
+    cursor: default !important;
+
+  }
+
+    .bp4-button:focus {
+      outline: none;
+    }
+
+  .bp4-tab {
+    cursor: default !important;
+  }
+
+  .bp4-menu-item {
+    cursor: default;
+  }
+
+    .bp4-menu-item, .bp4-menu .bp4-menu-item.bp4-disabled {
+      cursor: default !important;
+    }
+`;
+exports.BP4_RESET_CSS = BP4_RESET_CSS;

package/dependencies-local/extension-kit/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Progress } from './types/progress';\n\n\nexport type Entries<T> = {\n  [K in keyof T]: [K, T[K]];\n}[keyof T][];\n\n\nexport function stripLeadingSlash(fp: string): string {\n  return fp.replace(/^\\//, '');\n}\n\nexport function progressToValue(progress: Progress): number {\n  return 1 / progress.total * progress.loaded;\n}\n\nexport const encoder = new TextEncoder();\n\nexport const decoder = new TextDecoder('utf-8');\n\nexport type OnlyJSON<T> =\n  T extends string | number | boolean | null\n  ? T\n  : T extends Function\n    ? never\n    : T extends object\n      ? { [K in keyof T]: OnlyJSON<T[K]> }\n      : never;\n\n\n/**\n * Normalizes object by ensuring its keys are sorted.\n * May not be the most efficient way of doing so.\n */\nexport function normalizeObject<T extends Record<string, any>>(obj: T): T {\n  return Object.fromEntries(Object.entries(obj).sort()) as T;\n}\n\nexport function toJSONPreservingUndefined(\n  data: any,\n  indentation?: number,\n): string {\n  return (JSON.\n    stringify(\n      data || {},\n      (_, v) => (v === undefined) ? '__undefined' : v,\n      indentation).\n    replace(/\\\"__undefined\\\"/g, 'undefined'));\n}\n\n/**\n * NOTE: This is NOT a very fast implementation yet. Try to avoid.\n */\nexport function toJSONNormalized(val: any, indentation?: number) {\n  return toJSONPreservingUndefined(normalizeVal(val), indentation);\n}\n\n/**\n * @deprecated use `toJSONNormalized()` instead.\n */\nexport const JSONStringifyNormalized = toJSONNormalized;\n\nexport function objectsHaveSameShape(l: any, r: any): boolean {\n  return JSONStringifyNormalized(l) === JSONStringifyNormalized(r);\n}\n\n/**\n * Does the equivalent of `normalizeObject` on given object\n * as well as any objects encountered within.\n */\nexport function normalizeObjectRecursively\n<T extends Record<string, any>>\n(obj: T, _seen: null | WeakSet<any> = null): T {\n  const seen: WeakSet<any> = _seen ?? new WeakSet();\n\n  if (seen.has(obj)) {\n    return obj;\n  }\n\n  if (isObject(obj)) {\n    seen.add(obj);\n\n    const normalized = Object.fromEntries(\n      Object.entries(obj).\n        sort().\n        map(([key, val]) => [\n          key,\n          normalizeVal(val, seen),\n        ])\n      ) as T;\n\n    seen.delete(obj);\n\n    return normalized;\n  } else {\n    throw new Error(`Not an object: ${obj}`);\n  }\n}\n\nfunction normalizeVal<T>(val: T, _seen: null | WeakSet<any> = null): T {\n  const seen: WeakSet<any> = _seen ?? new WeakSet();\n\n  if (Array.isArray(val)) {\n    return val.map(v => isObject(v)\n      ? normalizeObjectRecursively(v, seen)\n      : v\n    ) as unknown as T;\n  } else if (isObject(val)) {\n    return normalizeObjectRecursively(val, seen);\n  } else {\n    return val;\n  }\n}\n\n/**\n * Returns true if given value is a regular object (‘hash’),\n * excluding “special” objects like dates etc.\n */\nexport function isObject(val: unknown): val is Record<string, any> {\n  return (\n    val !== null &&\n    typeof val === 'object' &&\n    !Array.isArray(val) &&\n    // val?.constructor === Object && // normal objects fail this one in extensions\n    val?.toString?.() === '[object Object]'\n  );\n}\n\n//function isArray(val: unknown): val is unknown[] {\n//  return val !== null && typeof val === 'object' && Array.isArray(val);\n//}\n\n\nexport const BP4_RESET_CSS = `\n  body, html {\n    -webkit-font-smoothing: antialiased;\n    font-family: -apple-system, BlinkMacSystemFont, avenir next, avenir, segoe ui, helvetica neue, helvetica, Ubuntu, roboto, noto, arial, sans-serif;\n  }\n\n  .filter-popover .bp4-popover2-content {\n    border-radius: 0;\n  }\n  .bp4-overlay-backdrop.bp4-popover2-backdrop {\n    background: rgba(0, 0, 0, .5);\n  }\n\n  .bp4-tag.bp4-interactive {\n    cursor: default !important;\n  }\n  .bp4-tag-remove {\n    cursor: default !important;\n  }\n\n  .bp4-input {\n    /*\n     * “middle”, specified by BP4, causes issues with inpout text <-> OL marker alignment.\n     * This seems to have no side-effects.\n     */\n    vertical-align: unset;\n  }\n  .bp4-input:read-only {\n    box-shadow: inset silver 1px -1px;\n    background: none;\n  }\n  .bp4-dark .bp4-input:read-only {\n    box-shadow: inset rgba(255, 255, 255, 0.2) 1px -1px;\n  }\n  .bp4-tree-node-caret {\n    cursor: default !important;\n  }\n\n  /* Why was it added? It breaks hover, definitely.\n    .bp4-tree-node-content:hover {\n      background: unset;\n    }\n  */\n\n  .bp4-html-select select {\n    cursor: default !important;\n  }\n\n  .bp4-button {\n    cursor: default !important;\n\n  }\n\n    .bp4-button:focus {\n      outline: none;\n    }\n\n  .bp4-tab {\n    cursor: default !important;\n  }\n\n  .bp4-menu-item {\n    cursor: default;\n  }\n\n    .bp4-menu-item, .bp4-menu .bp4-menu-item.bp4-disabled {\n      cursor: default !important;\n    }\n`;\n"]}

package/dependencies-local/extension-kit/widgets/DL.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+/**
+ * Definition list.
+ * Nest wrappers (like divs) with dt and dd within
+ * (`DLEntry` can be used to save time).
+ * NOTE: Wrappers are required. Only one DD per DT is allowed.
+ *
+ * Doesn’t work in narrow containers if DT and/or DD is too long,
+ * since DT and DD always begin on the same line.
+ */
+declare const DL: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: React.ElementType<any> | undefined;
+}, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDListElement>, HTMLDListElement>, {}>;
+/**
+ * For use with `DL`.
+ * Specify
+ */
+export declare const DLEntry: React.VoidFunctionComponent<{
+    term: JSX.Element | JSX.Element[] | string | string[];
+    definition: JSX.Element | JSX.Element[] | string | string[];
+    style?: React.CSSProperties;
+    className?: string;
+    dtStyle?: React.CSSProperties;
+    dtClassName?: string;
+    ddStyle?: React.CSSProperties;
+    ddClassName?: string;
+}>;
+/**
+ * Definition list where DT and DD can start on separate lines.
+ *
+ * Doesn’t work well for generic listings where it’s important
+ * for a nested object to always start to the right of key
+ * (never wrap to below).
+ */
+export declare const WrappableDL: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: React.ElementType<any> | undefined;
+} & React.ClassAttributes<HTMLDListElement> & React.HTMLAttributes<HTMLDListElement> & {
+    children?: React.ReactNode;
+} & {
+    theme?: import("@emotion/react").Theme | undefined;
+}, {}, {}>;
+export default DL;