main repo

node_modules/use-sidecar/dist/es5/config.d.ts

@@ -0,0 +1,5 @@
+export interface IConfig {
+    onError(e: Error): void;
+}
+export declare const config: IConfig;
+export declare const setConfig: (conf: Partial<IConfig>) => void;

node_modules/use-sidecar/dist/es5/config.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setConfig = exports.config = void 0;
+exports.config = {
+    onError: function (e) { return console.error(e); },
+};
+var setConfig = function (conf) {
+    Object.assign(exports.config, conf);
+};
+exports.setConfig = setConfig;

node_modules/use-sidecar/dist/es5/env.d.ts

@@ -0,0 +1,4 @@
+export declare const env: {
+    isNode: boolean;
+    forceCache: boolean;
+};

node_modules/use-sidecar/dist/es5/env.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = void 0;
+var detect_node_es_1 = require("detect-node-es");
+exports.env = {
+    isNode: detect_node_es_1.isNode,
+    forceCache: false,
+};

node_modules/use-sidecar/dist/es5/exports.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { SideCarComponent, SideCarMedium } from './types';
+export declare function exportSidecar<T>(medium: SideCarMedium<T>, exported: React.ComponentType<T>): SideCarComponent<T>;

node_modules/use-sidecar/dist/es5/exports.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportSidecar = void 0;
+var tslib_1 = require("tslib");
+var React = tslib_1.__importStar(require("react"));
+var SideCar = function (_a) {
+    var sideCar = _a.sideCar, rest = tslib_1.__rest(_a, ["sideCar"]);
+    if (!sideCar) {
+        throw new Error('Sidecar: please provide `sideCar` property to import the right car');
+    }
+    var Target = sideCar.read();
+    if (!Target) {
+        throw new Error('Sidecar medium not found');
+    }
+    return React.createElement(Target, tslib_1.__assign({}, rest));
+};
+SideCar.isSideCarExport = true;
+function exportSidecar(medium, exported) {
+    medium.useMedium(exported);
+    return SideCar;
+}
+exports.exportSidecar = exportSidecar;

node_modules/use-sidecar/dist/es5/hoc.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { Importer, SideCarHOC } from './types';
+export declare function sidecar<T>(importer: Importer<T>, errorComponent?: React.ReactNode): React.FunctionComponent<Omit<T, 'sideCar'> & SideCarHOC<Omit<T, 'sideCar'>>>;

node_modules/use-sidecar/dist/es5/hoc.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sidecar = void 0;
+var tslib_1 = require("tslib");
+var React = tslib_1.__importStar(require("react"));
+var hook_1 = require("./hook");
+// eslint-disable-next-line @typescript-eslint/ban-types
+function sidecar(importer, errorComponent) {
+    var ErrorCase = function () { return errorComponent; };
+    return function Sidecar(props) {
+        var _a = (0, hook_1.useSidecar)(importer, props.sideCar), Car = _a[0], error = _a[1];
+        if (error && errorComponent) {
+            return ErrorCase;
+        }
+        // @ts-expect-error type shenanigans
+        return Car ? React.createElement(Car, tslib_1.__assign({}, props)) : null;
+    };
+}
+exports.sidecar = sidecar;

node_modules/use-sidecar/dist/es5/hook.d.ts

@@ -0,0 +1,2 @@
+import { Importer, SideMedium } from './types';
+export declare function useSidecar<T>(importer: Importer<T>, effect?: SideMedium<any>): [React.ComponentType<T> | null, Error | null];

node_modules/use-sidecar/dist/es5/hook.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSidecar = void 0;
+var react_1 = require("react");
+var env_1 = require("./env");
+var cache = new WeakMap();
+var NO_OPTIONS = {};
+function useSidecar(importer, effect) {
+    var options = (effect && effect.options) || NO_OPTIONS;
+    if (env_1.env.isNode && !options.ssr) {
+        return [null, null];
+    }
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return useRealSidecar(importer, effect);
+}
+exports.useSidecar = useSidecar;
+function useRealSidecar(importer, effect) {
+    var options = (effect && effect.options) || NO_OPTIONS;
+    var couldUseCache = env_1.env.forceCache || (env_1.env.isNode && !!options.ssr) || !options.async;
+    var _a = (0, react_1.useState)(couldUseCache ? function () { return cache.get(importer); } : undefined), Car = _a[0], setCar = _a[1];
+    var _b = (0, react_1.useState)(null), error = _b[0], setError = _b[1];
+    (0, react_1.useEffect)(function () {
+        if (!Car) {
+            importer().then(function (car) {
+                var resolved = effect ? effect.read() : car.default || car;
+                if (!resolved) {
+                    console.error('Sidecar error: with importer', importer);
+                    var error_1;
+                    if (effect) {
+                        console.error('Sidecar error: with medium', effect);
+                        error_1 = new Error('Sidecar medium was not found');
+                    }
+                    else {
+                        error_1 = new Error('Sidecar was not found in exports');
+                    }
+                    setError(function () { return error_1; });
+                    throw error_1;
+                }
+                cache.set(importer, resolved);
+                setCar(function () { return resolved; });
+            }, function (e) { return setError(function () { return e; }); });
+        }
+    }, []);
+    return [Car, error];
+}

node_modules/use-sidecar/dist/es5/index.d.ts

@@ -0,0 +1,7 @@
+export { sidecar } from './hoc';
+export { useSidecar } from './hook';
+export { setConfig } from './config';
+export { createMedium, createSidecarMedium } from './medium';
+export { renderCar } from './renderProp';
+export { exportSidecar } from './exports';
+export type { SideCarComponent } from './types';

node_modules/use-sidecar/dist/es5/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportSidecar = exports.renderCar = exports.createSidecarMedium = exports.createMedium = exports.setConfig = exports.useSidecar = exports.sidecar = void 0;
+var hoc_1 = require("./hoc");
+Object.defineProperty(exports, "sidecar", { enumerable: true, get: function () { return hoc_1.sidecar; } });
+var hook_1 = require("./hook");
+Object.defineProperty(exports, "useSidecar", { enumerable: true, get: function () { return hook_1.useSidecar; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "setConfig", { enumerable: true, get: function () { return config_1.setConfig; } });
+var medium_1 = require("./medium");
+Object.defineProperty(exports, "createMedium", { enumerable: true, get: function () { return medium_1.createMedium; } });
+Object.defineProperty(exports, "createSidecarMedium", { enumerable: true, get: function () { return medium_1.createSidecarMedium; } });
+var renderProp_1 = require("./renderProp");
+Object.defineProperty(exports, "renderCar", { enumerable: true, get: function () { return renderProp_1.renderCar; } });
+var exports_1 = require("./exports");
+Object.defineProperty(exports, "exportSidecar", { enumerable: true, get: function () { return exports_1.exportSidecar; } });

node_modules/use-sidecar/dist/es5/medium.d.ts

@@ -0,0 +1,3 @@
+import { MiddlewareCallback, SideCarMedium, SideCarMediumOptions, SideMedium } from './types';
+export declare function createMedium<T>(defaults?: T, middleware?: MiddlewareCallback<T>): Readonly<SideMedium<T>>;
+export declare function createSidecarMedium<T = {}>(options?: SideCarMediumOptions): Readonly<SideCarMedium<T>>;

node_modules/use-sidecar/dist/es5/medium.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSidecarMedium = exports.createMedium = void 0;
+var tslib_1 = require("tslib");
+function ItoI(a) {
+    return a;
+}
+function innerCreateMedium(defaults, middleware) {
+    if (middleware === void 0) { middleware = ItoI; }
+    var buffer = [];
+    var assigned = false;
+    var medium = {
+        read: function () {
+            if (assigned) {
+                throw new Error('Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.');
+            }
+            if (buffer.length) {
+                return buffer[buffer.length - 1];
+            }
+            return defaults;
+        },
+        useMedium: function (data) {
+            var item = middleware(data, assigned);
+            buffer.push(item);
+            return function () {
+                buffer = buffer.filter(function (x) { return x !== item; });
+            };
+        },
+        assignSyncMedium: function (cb) {
+            assigned = true;
+            while (buffer.length) {
+                var cbs = buffer;
+                buffer = [];
+                cbs.forEach(cb);
+            }
+            buffer = {
+                push: function (x) { return cb(x); },
+                filter: function () { return buffer; },
+            };
+        },
+        assignMedium: function (cb) {
+            assigned = true;
+            var pendingQueue = [];
+            if (buffer.length) {
+                var cbs = buffer;
+                buffer = [];
+                cbs.forEach(cb);
+                pendingQueue = buffer;
+            }
+            var executeQueue = function () {
+                var cbs = pendingQueue;
+                pendingQueue = [];
+                cbs.forEach(cb);
+            };
+            var cycle = function () { return Promise.resolve().then(executeQueue); };
+            cycle();
+            buffer = {
+                push: function (x) {
+                    pendingQueue.push(x);
+                    cycle();
+                },
+                filter: function (filter) {
+                    pendingQueue = pendingQueue.filter(filter);
+                    return buffer;
+                },
+            };
+        },
+    };
+    return medium;
+}
+function createMedium(defaults, middleware) {
+    if (middleware === void 0) { middleware = ItoI; }
+    return innerCreateMedium(defaults, middleware);
+}
+exports.createMedium = createMedium;
+// eslint-disable-next-line @typescript-eslint/ban-types
+function createSidecarMedium(options) {
+    if (options === void 0) { options = {}; }
+    var medium = innerCreateMedium(null);
+    medium.options = tslib_1.__assign({ async: true, ssr: false }, options);
+    return medium;
+}
+exports.createSidecarMedium = createSidecarMedium;

node_modules/use-sidecar/dist/es5/renderProp.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { SideCarHOC } from './types';
+declare type CombinedProps<T extends any[], K> = {
+    children: (...prop: T) => any;
+} & K;
+declare type RenderPropComponent<T extends any[], K> = React.ComponentType<CombinedProps<T, K>>;
+export declare function renderCar<T extends any[], K, C = RenderPropComponent<T, K & Partial<SideCarHOC>>>(WrappedComponent: C, defaults: (props: K) => T): (props: CombinedProps<T, K>) => JSX.Element;
+export {};

node_modules/use-sidecar/dist/es5/renderProp.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCar = void 0;
+var tslib_1 = require("tslib");
+var React = tslib_1.__importStar(require("react"));
+var react_1 = require("react");
+function renderCar(WrappedComponent, defaults) {
+    function State(_a) {
+        var stateRef = _a.stateRef, props = _a.props;
+        var renderTarget = (0, react_1.useCallback)(function SideTarget() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            (0, react_1.useLayoutEffect)(function () {
+                stateRef.current(args);
+            });
+            return null;
+        }, []);
+        // @ts-ignore
+        return React.createElement(WrappedComponent, tslib_1.__assign({}, props, { children: renderTarget }));
+    }
+    var Children = React.memo(function (_a) {
+        var stateRef = _a.stateRef, defaultState = _a.defaultState, children = _a.children;
+        var _b = (0, react_1.useState)(defaultState.current), state = _b[0], setState = _b[1];
+        (0, react_1.useEffect)(function () {
+            stateRef.current = setState;
+        }, []);
+        return children.apply(void 0, state);
+    }, function () { return true; });
+    return function Combiner(props) {
+        var defaultState = React.useRef(defaults(props));
+        var ref = React.useRef(function (state) { return (defaultState.current = state); });
+        return (React.createElement(React.Fragment, null,
+            React.createElement(State, { stateRef: ref, props: props }),
+            React.createElement(Children, { stateRef: ref, defaultState: defaultState, children: props.children })));
+    };
+}
+exports.renderCar = renderCar;

node_modules/use-sidecar/dist/es5/types.d.ts

@@ -0,0 +1,47 @@
+import * as React from 'react';
+export declare type removeCb = () => void;
+export declare type MediumCallback<T> = (data: T) => any;
+export declare type MiddlewareCallback<T> = (data: T, assigned: boolean) => T;
+export declare type SidePush<T> = {
+    length?: number;
+    push(data: T): void;
+    filter(cb: (x: T) => boolean): SidePush<T>;
+};
+/**
+ * An object describing side medium
+ */
+export interface SideMedium<T> {
+    /**
+     * Pushes effect to the medium
+     * @param effect any information for real handler
+     */
+    useMedium(effect: T): removeCb;
+    /**
+     * Assigns effect handler to the medium
+     * @param {Function(effect: T)} handler effect handler
+     */
+    assignMedium(handler: MediumCallback<T>): void;
+    /**
+     * Assigns a synchronous effect handler to the medium, which would be executed right on call
+     * @param {Function(effect: T)} handler effect handler
+     */
+    assignSyncMedium(handler: MediumCallback<T>): void;
+    /**
+     * reads the data stored in the medium
+     */
+    read(): T | undefined;
+    options?: Record<string, any>;
+}
+export declare type DefaultOrNot<T> = {
+    default: T;
+} | T;
+export declare type Importer<T> = () => Promise<DefaultOrNot<React.ComponentType<T>>>;
+export declare type SideCarMedium<T = {}> = SideMedium<React.ComponentType<T>>;
+export declare type SideCarHOC<T = {}> = {
+    readonly sideCar: SideCarMedium<T>;
+};
+export declare type SideCarComponent<T> = React.FunctionComponent<T & SideCarHOC<T>>;
+export declare type SideCarMediumOptions = {
+    async?: boolean;
+    ssr?: boolean;
+};

node_modules/use-sidecar/dist/es5/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });