@cleanweb/oore 2.0.0-alpha.16 → 2.0.0-alpha.19

package/build/_cjs/classy/instance/mount-callbacks.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMountCallbacks = void 0;
+const react_1 = require("react");
+const mount_state_1 = require("../../helpers/mount-state");
+/** @internal */
+const useMountCallbacks = (instance) => {
+    var _a;
+    const isMounted = (0, mount_state_1.useMountState)();
+    if (!isMounted())
+        (_a = instance.beforeMount) === null || _a === void 0 ? void 0 : _a.call(instance);
+    (0, react_1.useEffect)(() => {
+        var _a;
+        const mountHandlerCleanUp = (_a = instance.onMount) === null || _a === void 0 ? void 0 : _a.call(instance);
+        return () => {
+            const doCleanUp = (runMountCleaners) => {
+                var _a;
+                runMountCleaners === null || runMountCleaners === void 0 ? void 0 : runMountCleaners();
+                (_a = instance.cleanUp) === null || _a === void 0 ? void 0 : _a.call(instance);
+            };
+            if (typeof mountHandlerCleanUp === 'function') {
+                doCleanUp(mountHandlerCleanUp);
+            }
+            else {
+                mountHandlerCleanUp === null || mountHandlerCleanUp === void 0 ? void 0 : mountHandlerCleanUp.then(doCleanUp);
+            }
+        };
+    }, []);
+};
+exports.useMountCallbacks = useMountCallbacks;

package/build/_cjs/classy/instance/types/hook.d.ts

@@ -0,0 +1,13 @@
+import { ComponentInstance } from '..';
+type UIClassParam = typeof ComponentInstance<NonNullable<any>>;
+type UIProplessClassParam = typeof ComponentInstance<null>;
+export type UseInstance = {
+    <Class extends UIProplessClassParam>(Methods: Class): InstanceType<Class>;
+    <Class extends UIClassParam>(Methods: Class, props: InstanceType<Class>['props']): InstanceType<Class>;
+};
+export type UIParams = [
+    Class: typeof ComponentInstance<any>,
+    props?: object
+];
+export type UIReturn = ComponentInstance<any>;
+export {};

package/build/_cjs/classy/instance/types/hook.js

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

package/build/_cjs/classy/logic/index.d.ts

@@ -0,0 +1,116 @@
+import type { TCleanState } from '../../base/state';
+import type { UseLogic } from './types/hook';
+/**
+ * The base type for the `props` type argument.
+ *
+ * This is not the type of the `props` property itself.
+ * It merely defines the type constraint for the type argument
+ * passed when extending any of the logic classes.
+ *
+ * It accepts null for components that don't take any props.
+ */
+export type TPropsBase = NonPrimitive | null;
+/**
+ * Base class for a class that holds methods to be used in a function component.
+ *
+ * These methods will always have access to the latest copy of
+ * the component's state and props via `this.state` and `this.props` respectively.
+ *
+ * The special {@link Class['useHooks'] | useHooks} method allows you to consume
+ * React hooks within this class.
+ *
+ * Call the {@link useLogic} hook inside your function component to instantiate the class.
+ *
+ * @typeParam TProps - {@include ./types/tprops.md}
+ */
+export declare class ComponentLogic<TProps extends TPropsBase = null> {
+    /**
+     * A {@link TCleanState | `CleanState`} object.
+     * Holds all of your component's state,
+     * and methods for conveniently manipulating those values.
+     * Initialiazed with the object returned from your `getInitialState` method.
+     */
+    readonly state: TCleanState<ReturnType<this['getInitialState']>>;
+    /** The props passed into your component at the time of rendering. */
+    readonly props: TProps extends null ? EmptyObject : TProps;
+    /**
+     * Values received from the hooks your component consumes.
+     * This holds the latest copy of the object returned by
+     * {@link useHooks}.
+     *
+     * You should not mutate this object directly.
+     * `useHooks` is called on every render and the object it returns
+     * will completely overwrite whatever the previous value of `this.hooks` was.
+     * `this.hooks` should only be updated through the object returned from `useHooks`.
+     *
+     * If you need to update a value from outside `useHooks` as well, then consider
+     * wrapping it with {@link React.useRef}, since React refs are persisted across rerenders.
+     */
+    readonly hooks: ReturnType<this['useHooks']>;
+    /**
+     * Called before each instance of your component is mounted.
+     * It receives the initial `props` object and should return
+     * an object with the initial values for your component's state.
+     */
+    getInitialState: (props: TProps extends null ? undefined : TProps) => object;
+    /**
+     * Call React hooks from here. If your component needs
+     * access to values return from the hooks you call,
+     * expose those values by returning an object with said values.
+     *
+     * The returned object will be accessible as {@link hooks | `this.hooks`} within
+     * your component class.
+     */
+    useHooks: () => object | void;
+    /**
+     * Persist class members during HMR. {@include ./hrm-preserve-keys.md}
+     * @privateRemarks
+     * @see {@link https://cleanjsweb.github.io/neat-react/classes/API.BaseClasses.ComponentLogic.html#_hmrpreservekeys | Full details}
+     */
+    _hmrPreserveKeys: Array<keyof this | (string & {})>;
+    /**
+     * Run custom logic after HMR update. {@include ./on-hrm-update.md}
+     * @privateRemarks
+     * @see {@link https://cleanjsweb.github.io/neat-react/classes/API.BaseClasses.ComponentLogic.html#_onhmrupdate | Full details}
+     */
+    _onHmrUpdate?: <TInstance extends this>(oldInstance: TInstance) => void;
+}
+/**
+ * Returns an instance of the provided class, which holds methods for your component and
+ * encapsulates hook calls with the special {@link ComponentLogic.useHooks | `useHooks`} method.
+ *
+ * The class argument must be a subclass of {@link ComponentLogic}.
+ *
+ * @see https://cleanjsweb.github.io/neat-react/functions/API.useLogic.html
+ */
+export declare const useLogic: UseLogic;
+/** /
+testing: {
+    const a: object = {b: ''};
+
+    type t = keyof typeof a;
+
+    class MyComponentLogic extends ComponentLogic<{}> {
+        getInitialState = () => ({b: 7});
+        b = () => 8 + this.state.b;
+
+        useHooks = () => ({a: 'undefined'});
+    };
+
+    type tt = keyof {};
+
+    const self = useLogic(MyComponentLogic);
+    self.hooks;
+    self.useHooks();
+
+
+    const A = class C extends ComponentLogic {
+        getInitialState = () => ({a: 'l'});
+        a = () => this.state.a = '';
+    }
+
+    // const oa = {['a' as unknown as symbol]: 'boo'};
+    const oa = {['a']: 'boo'};
+    useLogic(A, oa);
+}
+/**/

package/build/_cjs/classy/logic/index.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLogic = exports.ComponentLogic = void 0;
+const react_1 = require("react");
+const state_1 = require("../../base/state");
+/**
+ * Base class for a class that holds methods to be used in a function component.
+ *
+ * These methods will always have access to the latest copy of
+ * the component's state and props via `this.state` and `this.props` respectively.
+ *
+ * The special {@link Class['useHooks'] | useHooks} method allows you to consume
+ * React hooks within this class.
+ *
+ * Call the {@link useLogic} hook inside your function component to instantiate the class.
+ *
+ * @typeParam TProps - {@include ./types/tprops.md}
+ */
+class ComponentLogic {
+    constructor() {
+        /**
+         * Called before each instance of your component is mounted.
+         * It receives the initial `props` object and should return
+         * an object with the initial values for your component's state.
+         */
+        this.getInitialState = (props) => ({});
+        /**
+         * Call React hooks from here. If your component needs
+         * access to values return from the hooks you call,
+         * expose those values by returning an object with said values.
+         *
+         * The returned object will be accessible as {@link hooks | `this.hooks`} within
+         * your component class.
+         */
+        this.useHooks = () => { };
+        /**
+         * Persist class members during HMR. {@include ./hrm-preserve-keys.md}
+         * @privateRemarks
+         * @see {@link https://cleanjsweb.github.io/neat-react/classes/API.BaseClasses.ComponentLogic.html#_hmrpreservekeys | Full details}
+         */
+        this._hmrPreserveKeys = [];
+    }
+}
+exports.ComponentLogic = ComponentLogic;
+;
+/**
+ * Returns an instance of the provided class, which holds methods for your component and
+ * encapsulates hook calls with the special {@link ComponentLogic.useHooks | `useHooks`} method.
+ *
+ * The class argument must be a subclass of {@link ComponentLogic}.
+ *
+ * @see https://cleanjsweb.github.io/neat-react/functions/API.useLogic.html
+ */
+const useLogic = (...args) => {
+    var _a;
+    const [Logic, props = {}] = args;
+    // In production, we only use the latestInstance the first time, and it's ignored every other time.
+    // This means changing the class at runtime will have no effect in production.
+    // latestInstance is only extracted into a separate variable for use in dev mode during HMR.
+    const latestInstance = (0, react_1.useMemo)(() => new Logic(), [Logic]);
+    // const latestInstance = useMemo(() => new Logic(), []);
+    const instanceRef = (0, react_1.useRef)(latestInstance);
+    const refreshState = () => {
+        var _a;
+        // @ts-expect-error
+        instanceRef.current.props = props;
+        // @ts-expect-error
+        instanceRef.current.state = (0, state_1.useCleanState)(instanceRef.current.getInitialState, props);
+        // @ts-expect-error
+        instanceRef.current.hooks = (_a = instanceRef.current.useHooks()) !== null && _a !== void 0 ? _a : {};
+    };
+    if (process.env.NODE_ENV === 'development' && instanceRef.current !== latestInstance) {
+        const oldInstance = instanceRef.current;
+        latestInstance._hmrPreserveKeys.forEach((_key) => {
+            const key = _key;
+            // @ts-expect-error We're assigning to readonly properties. Also, Typescript doesn't know that the type of the left and right side will always match, due to the dynamic access.
+            latestInstance[key] = oldInstance[key];
+        });
+        Reflect.ownKeys(oldInstance).forEach((_key) => {
+            const key = _key;
+            delete oldInstance[key];
+        });
+        Object.setPrototypeOf(oldInstance, latestInstance);
+        instanceRef.current = latestInstance;
+        refreshState();
+        (_a = latestInstance._onHmrUpdate) === null || _a === void 0 ? void 0 : _a.call(latestInstance, oldInstance);
+    }
+    else
+        refreshState();
+    return instanceRef.current;
+    ;
+};
+exports.useLogic = useLogic;
+/** /
+testing: {
+    const a: object = {b: ''};
+
+    type t = keyof typeof a;
+
+    class MyComponentLogic extends ComponentLogic<{}> {
+        getInitialState = () => ({b: 7});
+        b = () => 8 + this.state.b;
+
+        useHooks = () => ({a: 'undefined'});
+    };
+
+    type tt = keyof {};
+
+    const self = useLogic(MyComponentLogic);
+    self.hooks;
+    self.useHooks();
+
+
+    const A = class C extends ComponentLogic {
+        getInitialState = () => ({a: 'l'});
+        a = () => this.state.a = '';
+    }
+
+    // const oa = {['a' as unknown as symbol]: 'boo'};
+    const oa = {['a']: 'boo'};
+    useLogic(A, oa);
+}
+/**/

package/build/_cjs/classy/logic/types/hook.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentLogic } from '..';
+/*************************************
+ *        # Hooks                    *
+**************************************/
+type ULClassParam = typeof ComponentLogic<NonNullable<any>>;
+type ULProplessClassParam = typeof ComponentLogic<null>;
+export type UseLogic = {
+    <Class extends ULProplessClassParam>(Methods: Class): InstanceType<Class>;
+    <Class extends ULClassParam>(Methods: Class, props: InstanceType<Class>['props']): InstanceType<Class>;
+};
+export type ULParams = [
+    Class: typeof ComponentLogic<any>,
+    props?: object
+];
+export type ULReturn = ComponentLogic<any>;
+export {};

package/build/_cjs/classy/logic/types/hook.js

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

package/build/_cjs/docs-src/api/base-classes.d.ts

@@ -0,0 +1,3 @@
+export { ComponentMethods } from '../../base/methods';
+export { ComponentLogic } from '../../classy/logic';
+export { ComponentInstance } from '../../classy/instance';

package/build/_cjs/docs-src/api/base-classes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentInstance = exports.ComponentLogic = exports.ComponentMethods = void 0;
+var methods_1 = require("../../base/methods");
+Object.defineProperty(exports, "ComponentMethods", { enumerable: true, get: function () { return methods_1.ComponentMethods; } });
+var logic_1 = require("../../classy/logic");
+Object.defineProperty(exports, "ComponentLogic", { enumerable: true, get: function () { return logic_1.ComponentLogic; } });
+var instance_1 = require("../../classy/instance");
+Object.defineProperty(exports, "ComponentInstance", { enumerable: true, get: function () { return instance_1.ComponentInstance; } });

package/build/_cjs/docs-src/api/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * API Reference
+ * @module API
+ */
+export { useCleanState } from '../../base/state';
+export { useMethods } from '../../base/methods';
+export { useLogic } from '../../classy/logic';
+export { useInstance } from '../../classy/instance';
+export { ClassComponent } from '../../classy/class';
+/** @namespace */
+export * as BaseClasses from './base-classes';
+export * as Helpers from '../../helpers';
+export * as References from './references';

package/build/_cjs/docs-src/api/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * API Reference
+ * @module API
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.References = exports.Helpers = exports.BaseClasses = exports.ClassComponent = exports.useInstance = exports.useLogic = exports.useMethods = exports.useCleanState = void 0;
+var state_1 = require("../../base/state");
+Object.defineProperty(exports, "useCleanState", { enumerable: true, get: function () { return state_1.useCleanState; } });
+var methods_1 = require("../../base/methods");
+Object.defineProperty(exports, "useMethods", { enumerable: true, get: function () { return methods_1.useMethods; } });
+var logic_1 = require("../../classy/logic");
+Object.defineProperty(exports, "useLogic", { enumerable: true, get: function () { return logic_1.useLogic; } });
+var instance_1 = require("../../classy/instance");
+Object.defineProperty(exports, "useInstance", { enumerable: true, get: function () { return instance_1.useInstance; } });
+var class_1 = require("../../classy/class");
+Object.defineProperty(exports, "ClassComponent", { enumerable: true, get: function () { return class_1.ClassComponent; } });
+/** @namespace */
+exports.BaseClasses = __importStar(require("./base-classes"));
+exports.Helpers = __importStar(require("../../helpers"));
+exports.References = __importStar(require("./references"));

package/build/_cjs/docs-src/api/references.d.ts

@@ -0,0 +1,5 @@
+export * as $CleanState from '../../base/state';
+export * as $ComponentMethods from '../../base/methods';
+export * as ComponentLogic from '../../classy/logic';
+export * as ComponentInstance from '../../classy/instance';
+export * as ClassComponent from '../../classy/class';

package/build/_cjs/docs-src/api/references.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassComponent = exports.ComponentInstance = exports.ComponentLogic = exports.$ComponentMethods = exports.$CleanState = void 0;
+exports.$CleanState = __importStar(require("../../base/state"));
+exports.$ComponentMethods = __importStar(require("../../base/methods"));
+exports.ComponentLogic = __importStar(require("../../classy/logic"));
+exports.ComponentInstance = __importStar(require("../../classy/instance"));
+exports.ClassComponent = __importStar(require("../../classy/class"));

package/build/_cjs/helpers/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Throw an error with the provided message
+ * only when `NODE_ENV` is *not* 'production'.
+ *
+ * In production, this falls back to just a console warning.
+ *
+ * Useful for enforcing certain conditions in development
+ * while failing more gracefully in production.
+ */
+export declare const throwDevError: (message: string) => void;

package/build/_cjs/helpers/errors.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwDevError = void 0;
+/**
+ * Throw an error with the provided message
+ * only when `NODE_ENV` is *not* 'production'.
+ *
+ * In production, this falls back to just a console warning.
+ *
+ * Useful for enforcing certain conditions in development
+ * while failing more gracefully in production.
+ */
+const throwDevError = (message) => {
+    if (process.env.NODE_ENV === 'production') {
+        console.warn(message);
+    }
+    else {
+        throw new Error(message);
+    }
+};
+exports.throwDevError = throwDevError;

package/build/_cjs/helpers/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * <!-- @ mergeModuleWith API -->
+ * @module Helpers
+ */
+export * from './mount-state';
+export * from './rerender';
+export * from './use-component';
+export * from './type-guards';
+/**
+ * An empty function.
+ * It returns (void) without performing any operations.
+ */
+export declare const noOp: () => void;

package/build/_cjs/helpers/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * <!-- @ mergeModuleWith API -->
+ * @module Helpers
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noOp = void 0;
+__exportStar(require("./mount-state"), exports);
+__exportStar(require("./rerender"), exports);
+__exportStar(require("./use-component"), exports);
+__exportStar(require("./type-guards"), exports);
+/**
+ * An empty function.
+ * It returns (void) without performing any operations.
+ */
+const noOp = () => { };
+exports.noOp = noOp;

package/build/_cjs/helpers/mount-state.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a value that is false before the component has been mounted,
+ * then true during all subsequent rerenders.
+ */
+export declare const useMountState: () => () => boolean;

package/build/_cjs/helpers/mount-state.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMountState = void 0;
+const react_1 = require("react");
+/**
+ * Returns a value that is false before the component has been mounted,
+ * then true during all subsequent rerenders.
+ */
+const useMountState = () => {
+    /**
+     * This must not be a state value. It should not be the cause of a rerender.
+     * It merely provides information about the render count,
+     * without influencing that count itself.
+     * So `mounted` should never be created with `useState`.
+     */
+    const mounted = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    return () => mounted.current;
+};
+exports.useMountState = useMountState;

package/build/_cjs/helpers/rerender.d.ts

@@ -0,0 +1,24 @@
+interface ICountRef {
+    current: number;
+}
+interface IRefresherReturn {
+    /** The last render count just before the rerender was triggered. */
+    previousCount: number;
+    /** A {@link useRef | RefObject} whose `current` property always has the latest render count. */
+    latestCountRef: ICountRef;
+}
+interface IRefresher {
+    (): Promise<IRefresherReturn>;
+}
+interface IUseRender {
+    (): IRefresher & {
+        /** The number of times this instance of the component has been (re)rendered. */
+        currentCount: number;
+    };
+}
+/**
+ * Returns a function that can be called to manually trigger
+ * a rerender of your component.
+ */
+export declare const useRerender: IUseRender;
+export {};

package/build/_cjs/helpers/rerender.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRerender = void 0;
+const react_1 = require("react");
+const mount_state_1 = require("../helpers/mount-state");
+;
+/**
+ * Returns a function that can be called to manually trigger
+ * a rerender of your component.
+ */
+const useRerender = () => {
+    const isMounted = (0, mount_state_1.useMountState)();
+    const renderCount = (0, react_1.useRef)(0);
+    const [, forceRerender] = (0, react_1.useState)(renderCount.current);
+    renderCount.current++;
+    const rerender = (0, react_1.useCallback)(() => {
+        let resolve;
+        const promise = new Promise((_r) => resolve = _r);
+        const execute = () => {
+            forceRerender(renderCount.current);
+            resolve({
+                previousCount: renderCount.current,
+                latestCountRef: renderCount,
+            });
+        };
+        if (isMounted())
+            execute();
+        else {
+            setTimeout(() => {
+                if (isMounted())
+                    execute();
+                else
+                    console.log('Cannot rerender an unmounted component.');
+            }, 1000);
+        }
+        return promise;
+    }, [forceRerender, renderCount]);
+    const refresher = () => rerender();
+    refresher.currentCount = renderCount.current;
+    return refresher;
+};
+exports.useRerender = useRerender;

package/build/_cjs/helpers/type-guards.d.ts

@@ -0,0 +1 @@
+export declare const canIndex: <T extends object>(key: keyof any, targetObject: T) => key is keyof T;

package/build/_cjs/helpers/type-guards.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canIndex = void 0;
+const canIndex = (key, targetObject) => {
+    const test = typeof key === 'number' ? `${key}` : key;
+    return Reflect.ownKeys(targetObject).includes(test);
+};
+exports.canIndex = canIndex;

package/build/_cjs/helpers/use-component/index.d.ts

@@ -0,0 +1,6 @@
+import type { ClassComponentHookWrapper } from './types';
+/**
+ * A component you can use to consume React hooks
+ * in a {@link Component | React.Component} class.
+ */
+export declare const Use: ClassComponentHookWrapper;

package/build/_cjs/helpers/use-component/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Use = void 0;
+const react_1 = require("react");
+/**
+ * A component you can use to consume React hooks
+ * in a {@link Component | React.Component} class.
+ */
+const Use = (params) => {
+    const { hook: useGenericHook, argumentsList, onUpdate } = params;
+    const output = useGenericHook(...argumentsList);
+    (0, react_1.useEffect)(() => {
+        onUpdate(output);
+    }, [output]);
+    return null;
+};
+exports.Use = Use;