@cleanweb/oore 2.0.0-alpha.33 → 2.0.0-alpha.35

package/build/classy/logic/index.js

@@ -1,5 +1,8 @@
-import { useMemo, useRef } from 'react';
-import { useCleanState } from '../../base/state/index.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLogic = exports.ComponentLogic = void 0;
+var react_1 = require("react");
+var state_1 = require("../../base/state");
 /**
  * Base class for a class that holds methods to be used in a function component.
  *
@@ -13,14 +16,14 @@ import { useCleanState } from '../../base/state/index.js';
  *
  * @typeParam TProps - {@include ./types/tprops.md}
  */
-export class ComponentLogic {
-    constructor() {
+var ComponentLogic = /** @class */ (function () {
+    function ComponentLogic() {
         /**
          * 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) => ({});
+        this.getInitialState = function (props) { return ({}); };
         /**
          * Call React hooks from here. If your component needs
          * access to values return from the hooks you call,
@@ -29,7 +32,7 @@ export class ComponentLogic {
          * The returned object will be accessible as {@link hooks | `this.hooks`} within
          * your component class.
          */
-        this.useHooks = () => { };
+        this.useHooks = function () { };
         /**
          * Persist class members during HMR. {@include ./hrm-preserve-keys.md}
          * @privateRemarks
@@ -37,7 +40,9 @@ export class ComponentLogic {
          */
         this._hmrPreserveKeys = [];
     }
-}
+    return ComponentLogic;
+}());
+exports.ComponentLogic = ComponentLogic;
 ;
 /**
  * Returns an instance of the provided class, which holds methods for your component and
@@ -47,45 +52,50 @@ export class ComponentLogic {
  *
  * @see https://cleanjsweb.github.io/neat-react/functions/API.useLogic.html
  */
-export const useLogic = (...args) => {
+var useLogic = function () {
     var _a;
-    const [Logic, props = {}] = args;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var Logic = args[0], _b = args[1], props = _b === void 0 ? {} : _b;
     // 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 = useMemo(() => new Logic(), [Logic]);
+    var latestInstance = (0, react_1.useMemo)(function () { return new Logic(); }, [Logic]);
     // const latestInstance = useMemo(() => new Logic(), []);
-    const instanceRef = useRef(latestInstance);
-    const refreshState = () => {
+    var instanceRef = (0, react_1.useRef)(latestInstance);
+    var refreshState = function () {
         var _a;
         // @ts-expect-error
         instanceRef.current.props = props;
         // @ts-expect-error
-        instanceRef.current.state = useCleanState(instanceRef.current.getInitialState, props);
+        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;
+        var oldInstance_1 = instanceRef.current;
+        latestInstance._hmrPreserveKeys.forEach(function (_key) {
+            var 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];
+            latestInstance[key] = oldInstance_1[key];
         });
-        Reflect.ownKeys(oldInstance).forEach((_key) => {
-            const key = _key;
-            delete oldInstance[key];
+        Reflect.ownKeys(oldInstance_1).forEach(function (_key) {
+            var key = _key;
+            delete oldInstance_1[key];
         });
-        Object.setPrototypeOf(oldInstance, latestInstance);
+        Object.setPrototypeOf(oldInstance_1, latestInstance);
         instanceRef.current = latestInstance;
         refreshState();
-        (_a = latestInstance._onHmrUpdate) === null || _a === void 0 ? void 0 : _a.call(latestInstance, oldInstance);
+        (_a = latestInstance._onHmrUpdate) === null || _a === void 0 ? void 0 : _a.call(latestInstance, oldInstance_1);
     }
     else
         refreshState();
     return instanceRef.current;
     ;
 };
+exports.useLogic = useLogic;
 /** /
 testing: {
     const a: object = {b: ''};

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

@@ -1,4 +1,4 @@
-import type { ComponentLogic } from '../index.js';
+import type { ComponentLogic } from '..';
 /*************************************
  *        # Hooks                    *
 **************************************/

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

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

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

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

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

@@ -1,3 +1,9 @@
-export { ComponentMethods } from '../../base/methods.js';
-export { ComponentLogic } from '../../classy/logic/index.js';
-export { ComponentInstance } from '../../classy/instance/index.js';
+"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/docs-src/api/index.d.ts

@@ -2,12 +2,12 @@
  * API Reference
  * @module API
  */
-export { useCleanState } from '../../base/state/index.js';
-export { useMethods } from '../../base/methods.js';
-export { useLogic } from '../../classy/logic/index.js';
-export { useInstance } from '../../classy/instance/index.js';
-export { ClassComponent } from '../../classy/class/index.js';
+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.js';
-export * as Helpers from '../../helpers/index.js';
-export * as References from './references.js';
+export * as BaseClasses from './base-classes';
+export * as Helpers from '../../helpers';
+export * as References from './references';

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

@@ -1,13 +1,44 @@
+"use strict";
 /**
  * API Reference
  * @module API
  */
-export { useCleanState } from '../../base/state/index.js';
-export { useMethods } from '../../base/methods.js';
-export { useLogic } from '../../classy/logic/index.js';
-export { useInstance } from '../../classy/instance/index.js';
-export { ClassComponent } from '../../classy/class/index.js';
+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 */
-export * as BaseClasses from './base-classes.js';
-export * as Helpers from '../../helpers/index.js';
-export * as References from './references.js';
+exports.BaseClasses = __importStar(require("./base-classes"));
+exports.Helpers = __importStar(require("../../helpers"));
+exports.References = __importStar(require("./references"));

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

@@ -1,5 +1,5 @@
-export * as $CleanState from '../../base/state/index.js';
-export * as $ComponentMethods from '../../base/methods.js';
-export * as ComponentLogic from '../../classy/logic/index.js';
-export * as ComponentInstance from '../../classy/instance/index.js';
-export * as ClassComponent from '../../classy/class/index.js';
+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/docs-src/api/references.js

@@ -1,5 +1,31 @@
-export * as $CleanState from '../../base/state/index.js';
-export * as $ComponentMethods from '../../base/methods.js';
-export * as ComponentLogic from '../../classy/logic/index.js';
-export * as ComponentInstance from '../../classy/instance/index.js';
-export * as ClassComponent from '../../classy/class/index.js';
+"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/globals.d.ts

@@ -1,131 +1,84 @@
-interface EmptyObject3 {
-	/**
-	 * It appears keys of the base `symbol` type are excluded from
-	 * excess property checks. This is likely a bug in TypeScript.
-	 * Even the "has no properties in common" error disappears if the
-	 * value being placed into a variable has a key typed as `symbol`.
-	 * This only applies to the base `symbol` type. Specifc `'unique symbol'`
-	 * types are unaffected.
-	 * 
-	 * @example
-	 * // Consider the following object:
-	 * const myUniqueSymbol = Symbol('lkjhgfc');
-	 * let myObj = { [myUniqueSymbol]?: 'a string value' };
-	 * 
-	 * // We can attempt to reassign `myObj` with the expectation that TS will
-	 * // warn if any key other than `myUniqueSymbol` is used in the new object.
-	 * // But this breaks in one specific scenario.
-	 * 
-	 * // No excess property check when this is used as a key.
-	 * // Error "no properties in common" also suppressed when this is used as a key.
-	 * const differentBasicSymbol = Symbol('qwertiop[') as symbol;
-	 * myObj = { [differentBasicSymbol]: 5 };
-	 * 
-	 * // Errors emitted as expected when this is used as a key.
-	 * const differentUniqueSymbol = Symbol('zxcvbnm');
-	 * myObj = { [differentUniqueSymbol]: 5 };
-	 */
-	[key: symbol]: never;
-}
-
-
-/////////////
-const UniqueSecretSymbolKey = Symbol('asdfghjkliuytrewqaxcvb,nb');
-
-type TEmptyObject1 = { ''?: never };
-type TEmptyObject2 = Record<keyof any, never>;
-
-type Optional<
-			BaseType,
-			AllowNull extends boolean = true
-		> = (
-	AllowNull extends true
-		? BaseType | undefined | null
-		: BaseType | undefined
-)
-
-type Awaitable<Type> = Type | Promise<Type>;
-
-type Constructor<
-	TInstance extends any = any,
-	TParams extends any[] = never[]
-> = new (...args: TParams) => TInstance;
-
-
-/**
- * @example
- * ```js
- * const getNumber: AsyncFunction<number> = async () => {
- * 	return 5;
- * }
- * ```
- */
-type AsyncFunction<
-	TReturnValue extends any = void,
-	Params extends any[] = never[]
-> = (...params: Params) => Promise<TReturnValue>
-
-/**
- * A function that takes no arguments and returns nothing.
- * Pass a type argument to set whether `async` and/or `sync` functions are allowed.
- */
-interface IVoidFunction<AsyncType extends 'async' | 'sync' | 'both' = 'both'> {
-	(): AsyncType extends 'async' ? Promise<void>
-		: AsyncType extends 'sync' ? void
-		: void | Promise<void>
-}
-
-type AnyFunction = (...args: any) => any;
-type FunctionType = AnyFunction;
-type TFunction = AnyFunction;
-
-/** @deprecated Use {@link NonNullish} */
-type NotNullish = {};
-type NonNullish = {};
-type NonPrimitive = object;
-
-
-/**
- * Describes an object that has no keys,
- * except for a secret unique symbol key,
- * whose value type is the union `never | undefuned`.
- * 
- * Having a single key allows the object to throw type errors
- * of the form:
- * ```
- * Type `A` has no properties in common with `EmptyObject`.
- * ```
- * This may provide a slightly stricter type checking than simply
- * using the non-nullish (`{}`) or non-primitive (`object`)
- * built-in types.
- * 
- * Note: `EmptyObject` is not assignable to `NeverObject`
- * because it has a key whose value type includes `undefined`,
- * but `NeverObject` keys can only have a type of `never`.
- */
-interface EmptyObject {
-	[UniqueSecretSymbolKey]?: never;
-}
-
-/**
- * Describes an object that can have any key, but all keys have
- * a type of `never`. This effectively prevents any value
- * from ever being stored on the object. The object is therefore
- * guaranteed to always be empty.
- */
-interface NeverObject {
-	[key: keyof any]: never;
-}
-
-type valueof<TObject> = TObject[keyof TObject];
-
-
-//////////////////
-interface Window {
-}
-
-namespace NodeJS {
-	interface ProcessEnv {
-		NODE_ENV: 'development' | 'production' | 'test',
-	}
+declare const UniqueSecretSymbolKey: unique symbol;
+/** /testing: {
+    const mySymbol = Symbol('asdfgh') as symbol;
+
+    const tt = {
+        // [mySymbol]: '' as never,
+        // [UniqueSecretSymbolKey]: '',
+        // '': '',
+    }
+
+    let TT: EmptyObject = {};
+    TT = tt;
+}/**/
+declare global {
+    type Optional<BaseType, AllowNull extends boolean = true> = (AllowNull extends true ? BaseType | undefined | null : BaseType | undefined);
+    type Awaitable<Type> = Type | Promise<Type>;
+    type Constructor<TInstance extends any = any, TParams extends any[] = never[]> = new (...args: TParams) => TInstance;
+    /**
+     * @example
+     * ```js
+     * const getNumber: AsyncFunction<number> = async () => {
+     * 	return 5;
+     * }
+     * ```
+     */
+    type AsyncFunction<TReturnValue extends any = void, Params extends any[] = never[]> = (...params: Params) => Promise<TReturnValue>;
+    /**
+     * A function that takes no arguments and returns nothing.
+     * Pass a type argument to set whether `async` and/or `sync` functions are allowed.
+     */
+    interface IVoidFunction<AsyncType extends 'async' | 'sync' | 'both' = 'both'> {
+        (): AsyncType extends 'async' ? Promise<void> : AsyncType extends 'sync' ? void : void | Promise<void>;
+    }
+    type AnyFunction = (...args: any) => any;
+    type FunctionType = AnyFunction;
+    type TFunction = AnyFunction;
+    /** @deprecated Use {@link NonNullish} */
+    type NotNullish = {};
+    type NonNullish = {};
+    type NonPrimitive = object;
+    /**
+     * Describes an object that has no keys,
+     * except for a secret unique symbol key,
+     * whose value type is the union `never | undefuned`.
+     *
+     * Having a single key allows the object to throw type errors
+     * of the form:
+     * ```
+     * Type `A` has no properties in common with `EmptyObject`.
+     * ```
+     * This may provide a slightly stricter type checking than simply
+     * using the non-nullish (`{}`) or non-primitive (`object`)
+     * built-in types.
+     *
+     * Note: `EmptyObject` is not assignable to `NeverObject`
+     * because it has a key whose value type includes `undefined`,
+     * but `NeverObject` keys can only have a type of `never`.
+     */
+    interface EmptyObject {
+        [UniqueSecretSymbolKey]?: never;
+    }
+    /**
+     * Describes an object that can have any key, but all keys have
+     * a type of `never`. This effectively prevents any value
+     * from ever being stored on the object. The object is therefore
+     * guaranteed to always be empty.
+     */
+    interface NeverObject {
+        [key: keyof any]: never;
+    }
+    type valueof<TObject> = TObject[keyof TObject];
+    interface Window {
+    }
+    namespace JSX {
+        interface IntrinsicElements {
+        }
+    }
+    namespace NodeJS {
+        interface ProcessEnv {
+            NODE_ENV: 'development' | 'production' | 'test';
+        }
+    }
 }
+export {};

package/build/globals.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/////////////
+var UniqueSecretSymbolKey = Symbol('asdfghjkliuytrewqaxcvb,nb');

package/build/helpers/errors.js

@@ -1,3 +1,6 @@
+"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'.
@@ -7,7 +10,7 @@
  * Useful for enforcing certain conditions in development
  * while failing more gracefully in production.
  */
-export const throwDevError = (message) => {
+var throwDevError = function (message) {
     if (process.env.NODE_ENV === 'production') {
         console.warn(message);
     }
@@ -15,3 +18,4 @@ export const throwDevError = (message) => {
         throw new Error(message);
     }
 };
+exports.throwDevError = throwDevError;

package/build/helpers/index.d.ts

@@ -2,13 +2,10 @@
  * <!-- @ mergeModuleWith API -->
  * @module Helpers
  */
-export * from './mount-state.js';
-export * from './rerender.js';
-export * from './use-component/index.js';
-export * from './object-gate.js';
-export * from './debounce/index.js';
-export * from './debounce/react-state.js';
-export * from './type-guards.js';
+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.

package/build/helpers/index.js

@@ -1,16 +1,31 @@
+"use strict";
 /**
  * <!-- @ mergeModuleWith API -->
  * @module Helpers
  */
-export * from './mount-state.js';
-export * from './rerender.js';
-export * from './use-component/index.js';
-export * from './object-gate.js';
-export * from './debounce/index.js';
-export * from './debounce/react-state.js';
-export * from './type-guards.js';
+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.
  */
-export const noOp = () => { };
+var noOp = function () { };
+exports.noOp = noOp;

package/build/helpers/mount-state.js

@@ -1,21 +1,25 @@
-import { useEffect, useRef } from 'react';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMountState = void 0;
+var react_1 = require("react");
 /**
  * Returns a value that is false before the component has been mounted,
  * then true during all subsequent rerenders.
  */
-export const useMountState = () => {
+var useMountState = function () {
     /**
      * 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 = useRef(false);
-    useEffect(() => {
+    var mounted = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(function () {
         mounted.current = true;
-        return () => {
+        return function () {
             mounted.current = false;
         };
     }, []);
-    return () => mounted.current;
+    return function () { return mounted.current; };
 };
+exports.useMountState = useMountState;