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

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

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMountCallbacks = void 0;
-var react_1 = require("react");
-var mount_state_1 = require("../../helpers/mount-state");
+const react_1 = require("react");
+const mount_state_1 = require("../../helpers/mount-state");
 /** @internal */
-var useMountCallbacks = function (instance) {
+const useMountCallbacks = (instance) => {
     var _a;
-    var isMounted = (0, mount_state_1.useMountState)();
+    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)(function () {
+    (0, react_1.useEffect)(() => {
         var _a;
-        var mountHandlerCleanUp = (_a = instance.onMount) === null || _a === void 0 ? void 0 : _a.call(instance);
-        return function () {
-            var doCleanUp = function (runMountCleaners) {
+        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);

package/build/classy/logic/index.js

@@ -1,8 +1,8 @@
 "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");
+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.
  *
@@ -16,14 +16,14 @@ var state_1 = require("../../base/state");
  *
  * @typeParam TProps - {@include ./types/tprops.md}
  */
-var ComponentLogic = /** @class */ (function () {
-    function ComponentLogic() {
+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 = function (props) { return ({}); };
+        this.getInitialState = (props) => ({});
         /**
          * Call React hooks from here. If your component needs
          * access to values return from the hooks you call,
@@ -32,7 +32,7 @@ var ComponentLogic = /** @class */ (function () {
          * The returned object will be accessible as {@link hooks | `this.hooks`} within
          * your component class.
          */
-        this.useHooks = function () { };
+        this.useHooks = () => { };
         /**
          * Persist class members during HMR. {@include ./hrm-preserve-keys.md}
          * @privateRemarks
@@ -40,8 +40,7 @@ var ComponentLogic = /** @class */ (function () {
          */
         this._hmrPreserveKeys = [];
     }
-    return ComponentLogic;
-}());
+}
 exports.ComponentLogic = ComponentLogic;
 ;
 /**
@@ -52,20 +51,16 @@ exports.ComponentLogic = ComponentLogic;
  *
  * @see https://cleanjsweb.github.io/neat-react/functions/API.useLogic.html
  */
-var useLogic = function () {
+const useLogic = (...args) => {
     var _a;
-    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;
+    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.
-    var latestInstance = (0, react_1.useMemo)(function () { return new Logic(); }, [Logic]);
+    const latestInstance = (0, react_1.useMemo)(() => new Logic(), [Logic]);
     // const latestInstance = useMemo(() => new Logic(), []);
-    var instanceRef = (0, react_1.useRef)(latestInstance);
-    var refreshState = function () {
+    const instanceRef = (0, react_1.useRef)(latestInstance);
+    const refreshState = () => {
         var _a;
         // @ts-expect-error
         instanceRef.current.props = props;
@@ -75,20 +70,20 @@ var useLogic = function () {
         instanceRef.current.hooks = (_a = instanceRef.current.useHooks()) !== null && _a !== void 0 ? _a : {};
     };
     if (process.env.NODE_ENV === 'development' && instanceRef.current !== latestInstance) {
-        var oldInstance_1 = instanceRef.current;
-        latestInstance._hmrPreserveKeys.forEach(function (_key) {
-            var key = _key;
+        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_1[key];
+            latestInstance[key] = oldInstance[key];
         });
-        Reflect.ownKeys(oldInstance_1).forEach(function (_key) {
-            var key = _key;
-            delete oldInstance_1[key];
+        Reflect.ownKeys(oldInstance).forEach((_key) => {
+            const key = _key;
+            delete oldInstance[key];
         });
-        Object.setPrototypeOf(oldInstance_1, latestInstance);
+        Object.setPrototypeOf(oldInstance, latestInstance);
         instanceRef.current = latestInstance;
         refreshState();
-        (_a = latestInstance._onHmrUpdate) === null || _a === void 0 ? void 0 : _a.call(latestInstance, oldInstance_1);
+        (_a = latestInstance._onHmrUpdate) === null || _a === void 0 ? void 0 : _a.call(latestInstance, oldInstance);
     }
     else
         refreshState();

package/build/globals.d.ts

@@ -1,84 +1,131 @@
-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';
-        }
-    }
+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',
+	}
 }
-export {};

package/build/helpers/errors.js

@@ -10,7 +10,7 @@ exports.throwDevError = void 0;
  * Useful for enforcing certain conditions in development
  * while failing more gracefully in production.
  */
-var throwDevError = function (message) {
+const throwDevError = (message) => {
     if (process.env.NODE_ENV === 'production') {
         console.warn(message);
     }

package/build/helpers/index.js

@@ -27,5 +27,5 @@ __exportStar(require("./type-guards"), exports);
  * An empty function.
  * It returns (void) without performing any operations.
  */
-var noOp = function () { };
+const noOp = () => { };
 exports.noOp = noOp;

package/build/helpers/mount-state.js

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

package/build/helpers/rerender.js

@@ -1,22 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useRerender = void 0;
-var react_1 = require("react");
-var mount_state_1 = require("../helpers/mount-state");
+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.
  */
-var useRerender = function () {
-    var isMounted = (0, mount_state_1.useMountState)();
-    var renderCount = (0, react_1.useRef)(0);
-    var _a = (0, react_1.useState)(renderCount.current), forceRerender = _a[1];
+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++;
-    var rerender = (0, react_1.useCallback)(function () {
-        var resolve;
-        var promise = new Promise(function (_r) { return resolve = _r; });
-        var execute = function () {
+    const rerender = (0, react_1.useCallback)(() => {
+        let resolve;
+        const promise = new Promise((_r) => resolve = _r);
+        const execute = () => {
             forceRerender(renderCount.current);
             resolve({
                 previousCount: renderCount.current,
@@ -26,7 +26,7 @@ var useRerender = function () {
         if (isMounted())
             execute();
         else {
-            setTimeout(function () {
+            setTimeout(() => {
                 if (isMounted())
                     execute();
                 else
@@ -35,7 +35,7 @@ var useRerender = function () {
         }
         return promise;
     }, [forceRerender, renderCount]);
-    var refresher = function () { return rerender(); };
+    const refresher = () => rerender();
     refresher.currentCount = renderCount.current;
     return refresher;
 };

package/build/helpers/type-guards.js

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

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

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

package/build/index.d.ts

@@ -1,4 +1,3 @@
 export * from './classy';
 export * from './base';
 export * from './helpers';
-export type { EmptyObject, NeverObject };

package/build/slots/hook.js

@@ -22,30 +22,21 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useSlots = exports.isPortalChild = exports.getComponentSlotName = exports.isElementChild = void 0;
-var errors_1 = require("../helpers/errors");
-var react_1 = __importStar(require("react"));
-var isElementChild = function (child) {
+const errors_1 = require("../helpers/errors");
+const react_1 = __importStar(require("react"));
+const isElementChild = (child) => {
     if (child && typeof child === 'object' && 'type' in child) {
         return true;
     }
     return false;
 };
 exports.isElementChild = isElementChild;
-var getComponentSlotName = function (TargetComponent, child) {
+const getComponentSlotName = (TargetComponent, child) => {
     if (child) {
-        var keyTypes = ['string', 'number', 'symbol'];
-        var slotName = child.props['data-slot-name'];
+        const keyTypes = ['string', 'number', 'symbol'];
+        const slotName = child.props['data-slot-name'];
         if (keyTypes.includes(typeof slotName)) {
             return slotName;
         }
@@ -62,7 +53,7 @@ var getComponentSlotName = function (TargetComponent, child) {
     return undefined;
 };
 exports.getComponentSlotName = getComponentSlotName;
-var isPortalChild = function (child) {
+const isPortalChild = (child) => {
     return (!!child
         && typeof child === 'object'
         && 'children' in child);
@@ -78,15 +69,14 @@ exports.isPortalChild = isPortalChild;
  *
  * @see {@link SlotComponent} for more on how to use the returned slot nodes.
  */
-var useSlots = function (children, Caller) {
-    var slotsAliasLookup = (0, react_1.useMemo)(function () {
-        var entries = Object.entries(Caller.Slots);
-        var aliasLookup = {};
-        entries.forEach(function (_a) {
-            var alias = _a[0], RegisteredSlotComponent = _a[1];
-            var slotName = (0, exports.getComponentSlotName)(RegisteredSlotComponent);
+const useSlots = (children, Caller) => {
+    const slotsAliasLookup = (0, react_1.useMemo)(() => {
+        const entries = Object.entries(Caller.Slots);
+        const aliasLookup = {};
+        entries.forEach(([alias, RegisteredSlotComponent]) => {
+            const slotName = (0, exports.getComponentSlotName)(RegisteredSlotComponent);
             if (!slotName) {
-                (0, errors_1.throwDevError)("A registered slot component did not have a slot name. All components registered as slots must either be a string tag-name or a React component with either \"slotName\" or \"displayName\". The affected component was: ".concat(RegisteredSlotComponent));
+                (0, errors_1.throwDevError)(`A registered slot component did not have a slot name. All components registered as slots must either be a string tag-name or a React component with either "slotName" or "displayName". The affected component was: ${RegisteredSlotComponent}`);
                 return;
             }
             aliasLookup[slotName] = alias;
@@ -94,21 +84,23 @@ var useSlots = function (children, Caller) {
         return aliasLookup;
     }, [Caller.Slots]);
     // @todo Expose original source order of `children` with respect to slot aliases.
-    var result = (0, react_1.useMemo)(function () {
+    const result = (0, react_1.useMemo)(() => {
         var _a;
-        var slotNodes = {};
-        var unmatchedChildren = [];
-        var invalidChildren = [];
-        var requiredSlotAliases = __spreadArray([], ((_a = Caller.requiredSlotAliases) !== null && _a !== void 0 ? _a : []), true);
-        react_1.default.Children.forEach(children, function (_child) {
+        const slotNodes = {};
+        const unmatchedChildren = [];
+        const invalidChildren = [];
+        const requiredSlotAliases = [
+            ...((_a = Caller.requiredSlotAliases) !== null && _a !== void 0 ? _a : [])
+        ];
+        react_1.default.Children.forEach(children, (_child) => {
             var _a;
-            var child = _child;
+            const child = _child;
             if (!child) {
                 invalidChildren.push(child);
                 return;
             }
             if (!react_1.default.isValidElement(child)) {
-                console.warn("Invalid node found in JSX children while parsing slots. Got: \"".concat(child, "\"."));
+                console.warn(`Invalid node found in JSX children while parsing slots. Got: "${child}".`);
                 invalidChildren.push(child);
                 return;
             }
@@ -118,9 +110,9 @@ var useSlots = function (children, Caller) {
                 unmatchedChildren.push(child);
                 return;
             }
-            var slotAlias = (function () {
+            const slotAlias = (() => {
                 var _a;
-                var slotName = (0, exports.getComponentSlotName)(child.type, child);
+                const slotName = (0, exports.getComponentSlotName)(child.type, child);
                 return slotName ? (_a = slotsAliasLookup[slotName]) !== null && _a !== void 0 ? _a : null : null;
             })();
             if (slotAlias) {
@@ -139,9 +131,9 @@ var useSlots = function (children, Caller) {
             else
                 unmatchedChildren.push(child);
         });
-        requiredSlotAliases.forEach(function (slotAlias) {
+        requiredSlotAliases.forEach((slotAlias) => {
             if (!slotNodes[slotAlias]) {
-                (0, errors_1.throwDevError)("Missing required slot \"".concat(String(slotAlias), "\"."));
+                (0, errors_1.throwDevError)(`Missing required slot "${String(slotAlias)}".`);
             }
         });
         return [slotNodes, unmatchedChildren, invalidChildren];