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

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

@@ -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 var throwDevError = function (message) {
+const throwDevError = (message) => {
     if (process.env.NODE_ENV === 'production') {
         console.warn(message);
     }
@@ -15,3 +18,4 @@ export var throwDevError = function (message) {
         throw new Error(message);
     }
 };
+exports.throwDevError = throwDevError;

package/build/helpers/index.js

@@ -1,13 +1,31 @@
+"use strict";
 /**
  * <!-- @ mergeModuleWith API -->
  * @module Helpers
  */
-export * from './mount-state';
-export * from './rerender';
-export * from './use-component';
-export * from './type-guards';
+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 var noOp = function () { };
+const noOp = () => { };
+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;
+const react_1 = require("react");
 /**
  * Returns a value that is false before the component has been mounted,
  * then true during all subsequent rerenders.
  */
-export 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 = useRef(false);
-    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,19 +1,22 @@
-import { useCallback, useRef, useState } from 'react';
-import { useMountState } from '../helpers/mount-state';
+"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.
  */
-export var useRerender = function () {
-    var isMounted = useMountState();
-    var renderCount = useRef(0);
-    var _a = 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 = 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,
@@ -23,7 +26,7 @@ export var useRerender = function () {
         if (isMounted())
             execute();
         else {
-            setTimeout(function () {
+            setTimeout(() => {
                 if (isMounted())
                     execute();
                 else
@@ -32,7 +35,8 @@ export var useRerender = function () {
         }
         return promise;
     }, [forceRerender, renderCount]);
-    var refresher = function () { return rerender(); };
+    const refresher = () => rerender();
     refresher.currentCount = renderCount.current;
     return refresher;
 };
+exports.useRerender = useRerender;

package/build/helpers/type-guards.js

@@ -1,4 +1,8 @@
-export var canIndex = function (key, targetObject) {
-    var test = typeof key === 'number' ? "".concat(key) : key;
+"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/helpers/use-component/index.js

@@ -1,13 +1,17 @@
-import { useEffect } from 'react';
+"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.
  */
-export var Use = function (params) {
-    var useGenericHook = params.hook, argumentsList = params.argumentsList, onUpdate = params.onUpdate;
-    var output = useGenericHook.apply(void 0, argumentsList);
-    useEffect(function () {
+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;

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

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

package/build/index.d.ts

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

package/build/index.js

@@ -1,3 +1,19 @@
-export * from './classy';
-export * from './base';
-export * from './helpers';
+"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("./classy"), exports);
+__exportStar(require("./base"), exports);
+__exportStar(require("./helpers"), exports);

package/build/slots/hook.js

@@ -1,24 +1,42 @@
-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];
-        }
+"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]; } };
     }
-    return to.concat(ar || Array.prototype.slice.call(from));
+    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;
 };
-import { throwDevError } from '../helpers/errors';
-import React, { useMemo } from 'react';
-export var isElementChild = function (child) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSlots = exports.isPortalChild = exports.getComponentSlotName = exports.isElementChild = void 0;
+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;
 };
-export var getComponentSlotName = function (TargetComponent, child) {
+exports.isElementChild = isElementChild;
+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;
         }
@@ -34,11 +52,13 @@ export var getComponentSlotName = function (TargetComponent, child) {
     }
     return undefined;
 };
-export var isPortalChild = function (child) {
+exports.getComponentSlotName = getComponentSlotName;
+const isPortalChild = (child) => {
     return (!!child
         && typeof child === 'object'
         && 'children' in child);
 };
+exports.isPortalChild = isPortalChild;
 /**
  * Groups `children` prop into predefined slots.
  *
@@ -49,15 +69,14 @@ export var isPortalChild = function (child) {
  *
  * @see {@link SlotComponent} for more on how to use the returned slot nodes.
  */
-export var useSlots = function (children, Caller) {
-    var slotsAliasLookup = useMemo(function () {
-        var entries = Object.entries(Caller.Slots);
-        var aliasLookup = {};
-        entries.forEach(function (_a) {
-            var alias = _a[0], RegisteredSlotComponent = _a[1];
-            var slotName = 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) {
-                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;
@@ -65,33 +84,35 @@ export var useSlots = function (children, Caller) {
         return aliasLookup;
     }, [Caller.Slots]);
     // @todo Expose original source order of `children` with respect to slot aliases.
-    var result = 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.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.isValidElement(child)) {
-                console.warn("Invalid node found in JSX children while parsing slots. Got: \"".concat(child, "\"."));
+            if (!react_1.default.isValidElement(child)) {
+                console.warn(`Invalid node found in JSX children while parsing slots. Got: "${child}".`);
                 invalidChildren.push(child);
                 return;
             }
             ;
             // @todo Check for fragment
-            if (!isElementChild(child)) {
+            if (!(0, exports.isElementChild)(child)) {
                 unmatchedChildren.push(child);
                 return;
             }
-            var slotAlias = (function () {
+            const slotAlias = (() => {
                 var _a;
-                var slotName = 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) {
@@ -110,12 +131,13 @@ export var useSlots = function (children, Caller) {
             else
                 unmatchedChildren.push(child);
         });
-        requiredSlotAliases.forEach(function (slotAlias) {
+        requiredSlotAliases.forEach((slotAlias) => {
             if (!slotNodes[slotAlias]) {
-                throwDevError("Missing required slot \"".concat(String(slotAlias), "\"."));
+                (0, errors_1.throwDevError)(`Missing required slot "${String(slotAlias)}".`);
             }
         });
         return [slotNodes, unmatchedChildren, invalidChildren];
     }, [children]);
     return result;
 };
+exports.useSlots = useSlots;

package/build/slots/index.js

@@ -1 +1,17 @@
-export * from './hook';
+"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("./hook"), exports);

package/build/slots/types.js

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