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

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

@@ -0,0 +1,3 @@
+export * from './state';
+export * from './methods';
+export * from './merged-state';

package/build/_cjs/base/index.js

@@ -0,0 +1,19 @@
+"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 __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 });
+__exportStar(require("./state"), exports);
+__exportStar(require("./methods"), exports);
+__exportStar(require("./merged-state"), exports);

package/build/_cjs/base/merged-state.d.ts

@@ -0,0 +1,20 @@
+import '../globals';
+declare class MergedState<TState extends object> {
+    static useRefresh<TState extends object>(this: MergedState<TState>): void;
+    reservedKeys: string[];
+    valueKeys: string[];
+    private _initialValues_;
+    private _values_;
+    private setState;
+    private _setters_;
+    get put(): { [Key in keyof TState]: (value: TState[Key]) => void; };
+    get initialState(): TState;
+    constructor(initialState: TState);
+    putMany: (newValues: Partial<TState>) => void;
+}
+/**
+ * Similar to {@link useCleanState},
+ * but uses a single `useState` call for the entire state object.
+ */
+export declare const useMergedState: <TState extends object>(initialState: TState) => MergedState<TState> & TState;
+export {};

package/build/_cjs/base/merged-state.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMergedState = void 0;
+require("../globals");
+const react_1 = require("react");
+class MergedState {
+    static useRefresh() {
+        [this._values_, this.setState] = (0, react_1.useState)(this.initialState);
+    }
+    get put() {
+        return Object.assign({}, this._setters_);
+    }
+    get initialState() {
+        return Object.assign({}, this._initialValues_);
+    }
+    constructor(initialState) {
+        this._initialValues_ = {};
+        this._values_ = {};
+        this._setters_ = {};
+        this.putMany = (newValues) => {
+            this.setState(Object.assign(Object.assign({}, this._values_), newValues));
+        };
+        this.reservedKeys = Object.keys(this);
+        this.valueKeys = [];
+        this._initialValues_ = Object.assign({}, initialState);
+        this._values_ = Object.assign({}, initialState);
+        Object.keys(initialState).forEach((_key) => {
+            const key = _key;
+            if (this.reservedKeys.includes(key)) {
+                throw new Error(`The name "${key}" is reserved by CleanState and cannot be used to index state variables. Please use a different key.`);
+            }
+            this.valueKeys.push(key);
+            this._setters_[key] = (value) => {
+                // this._values_[key] = value;
+                this.setState(Object.assign(Object.assign({}, this._values_), { [key]: value }));
+            };
+            const self = this;
+            Object.defineProperty(this, key, {
+                get() {
+                    return self._values_[key];
+                },
+                set(value) {
+                    self._setters_[key](value);
+                },
+                enumerable: true,
+            });
+        });
+    }
+}
+/**
+ * Similar to {@link useCleanState},
+ * but uses a single `useState` call for the entire state object.
+ */
+const useMergedState = (initialState) => {
+    const cleanState = (0, react_1.useRef)((0, react_1.useMemo)(() => {
+        return new MergedState(initialState);
+    }, [])).current;
+    MergedState.useRefresh.call(cleanState);
+    return cleanState;
+};
+exports.useMergedState = useMergedState;

package/build/_cjs/base/methods.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @module ComponentMethods
+ */
+/**
+ * @summary
+ * Base class for a class that holds methods for a function component.
+ *
+ * @remarks
+ * These methods will have access to the components state and props via
+ * `this.state` and `this.props` respectively.
+ *
+ * Call the {@link useMethods} hook inside your function component to instantiate the class.
+ */
+export declare class ComponentMethods<TProps extends object = {}, TState extends object | null = null> {
+    readonly props: TProps;
+    readonly state: TState;
+    /**
+     * Persist class members during HMR. {@include ../classy/logic/hrm-preserve-keys.md}
+     * @privateRemarks
+     * @see {@link https://cleanjsweb.github.io/neat-react/classes/API.BaseClasses.ComponentMethods.html#_hmrpreservekeys | Full details}
+     */
+    _hmrPreserveKeys: Array<keyof this | (string & {})>;
+    /**
+     * Run custom logic after HMR update. {@include ../classy/logic/on-hrm-update.md}
+     * @privateRemarks
+     * @see {@link https://cleanjsweb.github.io/neat-react/classes/API.BaseClasses.ComponentMethods.html#_onhmrupdate | Full details}
+     */
+    _onHmrUpdate?: <TInstance extends this>(oldInstance: TInstance) => void;
+}
+type UseMethods = {
+    <Class extends typeof ComponentMethods<object, object>>(Methods: Class & Constructor<InstanceType<Class>>, props: InstanceType<Class>['props'], state: InstanceType<Class>['state']): InstanceType<Class>;
+    <Class extends typeof ComponentMethods<object, null>>(Methods: Class & Constructor<InstanceType<Class>>, props: InstanceType<Class>['props'], state?: null): InstanceType<Class>;
+    <Class extends typeof ComponentMethods<NeverObject, null>>(Methods: Class & Constructor<InstanceType<Class>>): InstanceType<Class>;
+};
+/**
+ * Returns an instance of the provided class,
+ * with the state and props arguments added as instance members.
+ *
+ * `state` should be an instance of `CleanState` created with {@link useCleanState}.
+ */
+declare const useMethods: UseMethods;
+export { useMethods };
+/** /type_testing: {
+    let a = async () => {
+        const a: object = {b: ''};
+
+        type t = keyof typeof a;
+
+        class MyMethods extends ComponentMethods<EmptyObject, null> {
+            // static getInitialState = () => ({});
+        };
+
+        const { useCleanState } = (await import('./state.js'));
+
+        const self = useMethods(MyMethods, {});
+        self.state;
+    }
+}/**/

package/build/_cjs/base/methods.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * @module ComponentMethods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMethods = exports.ComponentMethods = void 0;
+// Values
+const react_1 = require("react");
+/**
+ * @summary
+ * Base class for a class that holds methods for a function component.
+ *
+ * @remarks
+ * These methods will have access to the components state and props via
+ * `this.state` and `this.props` respectively.
+ *
+ * Call the {@link useMethods} hook inside your function component to instantiate the class.
+ */
+class ComponentMethods {
+    constructor() {
+        /**
+         * Persist class members during HMR. {@include ../classy/logic/hrm-preserve-keys.md}
+         * @privateRemarks
+         * @see {@link https://cleanjsweb.github.io/neat-react/classes/API.BaseClasses.ComponentMethods.html#_hmrpreservekeys | Full details}
+         */
+        this._hmrPreserveKeys = []; // @todo Keep undefined. Update to empty array after instantiation in dev env.
+    }
+}
+exports.ComponentMethods = ComponentMethods;
+;
+/**
+ * Returns an instance of the provided class,
+ * with the state and props arguments added as instance members.
+ *
+ * `state` should be an instance of `CleanState` created with {@link useCleanState}.
+ */
+const useMethods = (...args) => {
+    var _a;
+    const [Methods, props = {}, state] = args;
+    // Vite HMR seems to sometimes reinitialize useMemo calls after a hot update,
+    // causing the instance to be unexpectedly recreated in the middle of the component's lifecycle.
+    // But useRef and useState values appear to always be preserved whenever this happens.
+    // So those two are the only cross-render-persistence methods we can consider safe.
+    // 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 Methods(), [Methods]);
+    const instanceRef = (0, react_1.useRef)(latestInstance);
+    const refreshState = () => {
+        // @ts-expect-error
+        instanceRef.current.props = props;
+        // @ts-expect-error
+        if (state)
+            instanceRef.current.state = state;
+    };
+    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];
+        });
+        // Ensure that any stale references to oldInstance within the app
+        // will end up retrieving up-to-date values from latestInstance
+        // through the prototype chain.
+        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.useMethods = useMethods;
+/** /type_testing: {
+    let a = async () => {
+        const a: object = {b: ''};
+
+        type t = keyof typeof a;
+
+        class MyMethods extends ComponentMethods<EmptyObject, null> {
+            // static getInitialState = () => ({});
+        };
+
+        const { useCleanState } = (await import('./state.js'));
+
+        const self = useMethods(MyMethods, {});
+        self.state;
+    }
+}/**/

package/build/_cjs/base/state/class-types.d.ts

@@ -0,0 +1,20 @@
+import { CleanStateBase } from './class';
+import { TCleanState, TStateData } from './hook-types';
+export type TCleanStateBase = typeof CleanStateBase;
+export type TCleanStateBaseKeys = keyof TCleanStateBase;
+export type PutState<TState extends TStateData> = {
+    [Key in keyof TState]: React.Dispatch<React.SetStateAction<TState[Key]>>;
+};
+export type PutManyPayload<TState extends TStateData> = {
+    [Key in keyof TState]?: React.SetStateAction<TState[Key]>;
+};
+export type StateFragment<TComponent extends {
+    getInitialState: (...args: any[]) => TStateData;
+}> = PutManyPayload<ReturnType<TComponent['getInitialState']>>;
+export type { StateFragment as SF };
+export interface ICleanStateConstructor {
+    new <TState extends object>(...args: ConstructorParameters<typeof CleanStateBase>): TCleanState<TState>;
+}
+export type ICleanStateClass = ICleanStateConstructor & {
+    [Key in TCleanStateBaseKeys]: (typeof CleanStateBase)[Key];
+};

package/build/_cjs/base/state/class-types.js

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

package/build/_cjs/base/state/class.d.ts

@@ -0,0 +1,69 @@
+import type { ICleanStateClass, ICleanStateConstructor, PutManyPayload, PutState } from './class-types';
+/** @internal */
+export declare class CleanStateBase<TState extends Record<string, any>> {
+    readonly reservedKeys: string[];
+    readonly valueKeys: string[];
+    private _values_;
+    private _initialValues_;
+    private _setters_;
+    constructor(initialState: TState);
+    static update: <TState_1 extends object>(this: CleanStateBase<TState_1>) => void;
+    get put(): PutState<TState>;
+    get initialState(): TState;
+    /**
+     * Accepts an object to be merged into the current state object,
+     * updating the values of specified keys to their specified values.
+     *
+     * All specified keys must be present on the initial state object.
+     * This is a requirement of React hooks, as the number of calls to
+     * useState must be the same throughout a component's lifetime.
+     *
+     * To dynamically add new keys to your state object, use a nested object,
+     * or use the {@link useMergedState | `useMergedState`} hook also exported by this library.
+     *
+     * When called from inside a component class, the type of the object passed
+     * must be explicitly specified with a type assertion.
+     * This is because the component classes use the dynamic `this` type to define
+     * the type of their state property.
+     *
+     * Use the `StateFragment` type, also aliased as `SF`, to define this type assertion.
+     * The assertion is not needed when calling putMany from outside the class.
+     *
+     * @example <caption>Using `putMany`</caption>
+     * import type { SF } from '@cleanweb/oore/base';
+     * import { ComponentLogic } from '@cleanweb/oore';
+     *
+     * class InputCL extends ComponentLogic<TProps> {
+     *     getInitialState(props: TProps): TState => ({
+     *         disabled: true,
+     *     });
+     *
+     *     enableInput = () => {
+     *         this.state.putMany({
+     *             disabled: false,
+     *         } as SF<this>); // Type assertion required inside class.
+     *     };
+     * }
+     *
+     * export const Input = (props: TProps) => {
+     *     const self = useLogic(InputCL, props);
+     *
+     *     return <>
+     *         {
+     *             // Other elements...
+     *         }
+     *         <button className="cta"
+     *                 onClick={() => {
+     *                     self.state.putMany({
+     *                         disabled: true
+     *                     }); // No type assertion needed outside the class.
+     *                 }}>
+     *             Submit
+     *         </button>
+     *     </>;
+     * };
+     */
+    readonly putMany: (newValues: PutManyPayload<TState>) => void;
+}
+/** @internal */
+export declare const CleanState: (ICleanStateConstructor & ICleanStateClass);

package/build/_cjs/base/state/class.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CleanState = exports.CleanStateBase = void 0;
+const react_1 = require("react");
+/** @internal */
+class CleanStateBase {
+    constructor(initialState) {
+        this._values_ = {};
+        this._setters_ = {};
+        /**
+         * Accepts an object to be merged into the current state object,
+         * updating the values of specified keys to their specified values.
+         *
+         * All specified keys must be present on the initial state object.
+         * This is a requirement of React hooks, as the number of calls to
+         * useState must be the same throughout a component's lifetime.
+         *
+         * To dynamically add new keys to your state object, use a nested object,
+         * or use the {@link useMergedState | `useMergedState`} hook also exported by this library.
+         *
+         * When called from inside a component class, the type of the object passed
+         * must be explicitly specified with a type assertion.
+         * This is because the component classes use the dynamic `this` type to define
+         * the type of their state property.
+         *
+         * Use the `StateFragment` type, also aliased as `SF`, to define this type assertion.
+         * The assertion is not needed when calling putMany from outside the class.
+         *
+         * @example <caption>Using `putMany`</caption>
+         * import type { SF } from '@cleanweb/oore/base';
+         * import { ComponentLogic } from '@cleanweb/oore';
+         *
+         * class InputCL extends ComponentLogic<TProps> {
+         *     getInitialState(props: TProps): TState => ({
+         *         disabled: true,
+         *     });
+         *
+         *     enableInput = () => {
+         *         this.state.putMany({
+         *             disabled: false,
+         *         } as SF<this>); // Type assertion required inside class.
+         *     };
+         * }
+         *
+         * export const Input = (props: TProps) => {
+         *     const self = useLogic(InputCL, props);
+         *
+         *     return <>
+         *         {
+         *             // Other elements...
+         *         }
+         *         <button className="cta"
+         *                 onClick={() => {
+         *                     self.state.putMany({
+         *                         disabled: true
+         *                     }); // No type assertion needed outside the class.
+         *                 }}>
+         *             Submit
+         *         </button>
+         *     </>;
+         * };
+         */
+        this.putMany = (newValues) => {
+            Object.entries(newValues).forEach((entry) => {
+                const [key, value] = entry;
+                this.put[key](value);
+            });
+        };
+        this.reservedKeys = Object.keys(this);
+        /**
+         * The keys from the initial state object.
+         * By capturing and storing the value once, we ensure that any potential changes to the object,
+         * or irregularities in the order of keys returned by Object.keys,
+         * will not affect the order of subsequent useState calls.
+         * Only keys provided on the initial call will be recognized,
+         * since CleanState is instantiated only once with useMemo,
+         * and they will always be processed in a consistent order during rerenders.
+         */
+        this.valueKeys = Object.keys(initialState);
+        this._initialValues_ = Object.assign({}, initialState);
+        this.valueKeys.forEach((key) => {
+            if (this.reservedKeys.includes(key))
+                throw new Error(`The name "${key}" is reserved by CleanState and cannot be used to index state variables. Please use a different key.`);
+            const self = this;
+            Object.defineProperty(this, key, {
+                get() {
+                    return self._values_[key];
+                },
+                set(value) {
+                    self._setters_[key](value);
+                },
+                enumerable: true,
+            });
+        });
+    }
+    get put() {
+        return Object.assign({}, this._setters_);
+    }
+    get initialState() {
+        return Object.assign({}, this._initialValues_);
+    }
+}
+exports.CleanStateBase = CleanStateBase;
+CleanStateBase.update = function update() {
+    if (!(this instanceof exports.CleanState))
+        throw new Error('CleanState.update must be called with `this` value set to a CleanState instance. Did you forget to use `.call` or `.apply`? Example: CleanState.update.call(cleanState);');
+    /**
+     * Linters complain about the use of a React hook within a loop because:
+     * > By following this rule, you ensure that Hooks are called in the same order each time a component renders.
+     * > That’s what allows React to correctly preserve the state of Hooks between multiple useState and useEffect calls.
+     * To resolve this, we're calling `useState` via an alias `retrieveState`.
+     * Bypassing this rule is safe here because `useCleanState` is a special case,
+     * and it guarantees that the same useState calls will be made on every render in the exact same order.
+     * Therefore, it is safe to silence the linters, and required for this implementation to work smoothly.
+     */
+    const retrieveState = react_1.useState;
+    this.valueKeys.forEach((key) => {
+        // @todo Make state updates accessible immediately. Use state.staged to access the scheduled updates.
+        let setter;
+        [this._values_[key], setter] = retrieveState(this.initialState[key]);
+        this._setters_[key] = ((valueOrCallback) => {
+            // this._staged_[key] = value;
+            setter(valueOrCallback);
+        });
+    });
+};
+;
+/** @internal */
+exports.CleanState = (CleanStateBase);

package/build/_cjs/base/state/hook-types.d.ts

@@ -0,0 +1,32 @@
+import { CleanStateBase } from './class';
+/**
+ * Base type for an `initialState` object.
+ * It is a regular object type, with some reserved keys excluded.
+ */
+export type TStateData = object & {
+    [Key in keyof CleanStateBase<{}>]?: never;
+};
+/**
+ * Describes a `CleanState` object instantiated with an `initialState`
+ * object of type `TState`.
+ *
+ * @typeParam TState - The type of your `initialState` object.
+ */
+export type TCleanState<TState extends TStateData> = (CleanStateBase<TState> & Omit<TState, keyof CleanStateBase<{}>>);
+/**
+ * Takes a `TCleanState` type and returns the `initialState` type
+ * associated with the provided `TCleanState`.
+ *
+ * This is useful to isolate the type of your actual state data without
+ * any of the reserved keys provided by the Clean State utility.
+ */
+export type ExtractCleanStateData<YourCleanState extends CleanStateBase<{}>> = Omit<YourCleanState, keyof CleanStateBase<{}>>;
+type StateInitFunction = (...args: any[]) => object;
+type StateInit = object | StateInitFunction;
+export type TInitialState<Initializer extends StateInit> = Initializer extends (...args: any[]) => (infer TState extends object) ? TState : Initializer;
+/**
+ * @typeParam TInit - An initial state object, or a function that
+ * returns the initial state object.
+ */
+export type TUseCleanState = <TInit extends StateInit>(_initialState: TInit, ...props: TInit extends (...args: infer TProps extends any[]) => (infer TState extends object) ? TProps : []) => TCleanState<TInitialState<TInit>>;
+export {};

package/build/_cjs/base/state/hook-types.js

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

package/build/_cjs/base/state/hooks.d.ts

@@ -0,0 +1,12 @@
+import { TUseCleanState } from './hook-types';
+/**
+ * Creates a state object, which includes the provided values,
+ * as well as helper methods for updating those values and automatically
+ * rerendering your component's UI to reflect the updates.
+ *
+ * Uses {@link React.useState} under the hood, with a separate call
+ * to `useState` for each top-level key in the provided object.
+ *
+ * Discussion: [When to `useCleanState`](https://cleanjsweb.github.io/neat-react/documents/Clean_State.html).
+ */
+export declare const useCleanState: TUseCleanState;

package/build/_cjs/base/state/hooks.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCleanState = void 0;
+const react_1 = require("react");
+const class_1 = require("./class");
+/**
+ * Creates a state object, which includes the provided values,
+ * as well as helper methods for updating those values and automatically
+ * rerendering your component's UI to reflect the updates.
+ *
+ * Uses {@link React.useState} under the hood, with a separate call
+ * to `useState` for each top-level key in the provided object.
+ *
+ * Discussion: [When to `useCleanState`](https://cleanjsweb.github.io/neat-react/documents/Clean_State.html).
+ */
+const useCleanState = (_initialState, ...props) => {
+    const initialState = typeof _initialState === 'function'
+        ? (0, react_1.useMemo)(() => _initialState(...props), [])
+        : _initialState;
+    ;
+    const cleanState = (0, react_1.useRef)((0, react_1.useMemo)(() => {
+        return new class_1.CleanState(initialState);
+    }, [])).current;
+    class_1.CleanState.update.call(cleanState);
+    return cleanState;
+};
+exports.useCleanState = useCleanState;
+// Should be valid.
+// useCleanState((a: number) => ({b: a.toString(), q: 1}), 6);
+// useCleanState((a: boolean) => ({b: a.toString()}), true);
+// useCleanState((a: number, c?: string) => ({ b: `${a}` }), 6);
+// useCleanState((a: number, c?: string) => ({ b: `${a}` }), 6, 'word');
+// useCleanState((a: number, c: string) => ({ b: a + c, f: true }), 6, 'text');
+// useCleanState({ d: 5000 });
+// Should fail.
+// useCleanState((a: number) => ({b: a.toString(), q: 1}), 6, false);
+// useCleanState((a: boolean) => ({b: a.toString()}));
+// useCleanState((a: number, c?: string) => ({ b: `${a}` }), '6');
+// useCleanState((a: number, c?: string) => ({ b: `${a}` }));
+// useCleanState((a: number, c: string) => ({ b: a + c, f: true }), 6, 7);
+// useCleanState({ d: 5000 }, true);

package/build/_cjs/base/state/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module CleanState
+ */
+import '../../globals';
+export { CleanState } from './class';
+export { useCleanState } from './hooks';
+export type { TCleanState, TStateData, ExtractCleanStateData } from './hook-types';
+export type { SF, StateFragment } from './class-types';
+export * as MergedState from '../../base/merged-state';

package/build/_cjs/base/state/index.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @module CleanState
+ */
+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.MergedState = exports.useCleanState = exports.CleanState = void 0;
+require("../../globals");
+var class_1 = require("./class");
+Object.defineProperty(exports, "CleanState", { enumerable: true, get: function () { return class_1.CleanState; } });
+var hooks_1 = require("./hooks");
+Object.defineProperty(exports, "useCleanState", { enumerable: true, get: function () { return hooks_1.useCleanState; } });
+exports.MergedState = __importStar(require("../../base/merged-state"));