@cleanweb/react 1.1.1-beta.2 → 1.1.1-beta.21

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

@@ -1,3 +1,4 @@
+import '../globals';
 declare class MergedState<TState extends object> {
     static useRefresh<TState extends object>(this: MergedState<TState>): void;
     reservedKeys: string[];

package/build/base/merged-state.js

@@ -12,6 +12,7 @@ var __assign = (this && this.__assign) || function () {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMergedState = void 0;
+require("../globals");
 var react_1 = require("react");
 var MergedState = /** @class */ (function () {
     function MergedState(initialState) {
@@ -70,7 +71,9 @@ var MergedState = /** @class */ (function () {
     return MergedState;
 }());
 var useMergedState = function (initialState) {
-    var cleanState = (0, react_1.useMemo)(function () { return new MergedState(initialState); }, []);
+    var cleanState = (0, react_1.useMemo)(function () {
+        return new MergedState(initialState);
+    }, []);
     MergedState.useRefresh.call(cleanState);
     return cleanState;
 };

package/build/base/methods.d.ts

@@ -1,8 +1,25 @@
-import type { TCleanState } from './state';
-export declare class ComponentMethods<TState extends object, TProps extends object> {
-    state: TCleanState<TState>;
-    props: TProps;
+import type { TCleanState, TStateData } from './state';
+/**
+ * Base class for a class that holds methods intended for use in a function component.
+ * 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 TStateData | null = null> {
+    readonly props: TProps;
+    state: TState extends TStateData ? TCleanState<TState> : null;
 }
-type UseMethods = <TMethods extends typeof ComponentMethods<any, any>, Instance extends InstanceType<TMethods> = InstanceType<TMethods>>(Methods: TMethods & Constructor<InstanceType<TMethods>>, state: InstanceType<TMethods>['state'], props: InstanceType<TMethods>['props']) => InstanceType<TMethods>;
-export declare const useMethods: UseMethods;
-export {};
+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<HardEmptyObject, 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` must be an instance of `CleanState` created with {@link useCleanState}.
+ */
+declare const useMethods: UseMethods;
+export { useMethods };

package/build/base/methods.js

@@ -1,58 +1,15 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMethods = exports.ComponentMethods = void 0;
+// Values
 var react_1 = require("react");
+/**
+ * Base class for a class that holds methods intended for use in a function component.
+ * 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.
+ */
 var ComponentMethods = /** @class */ (function () {
     function ComponentMethods() {
     }
@@ -60,41 +17,48 @@ var ComponentMethods = /** @class */ (function () {
 }());
 exports.ComponentMethods = ComponentMethods;
 ;
-var useMethods = function (Methods, state, props) {
-    // @todo Switch to useRef. Vite HMR seems to sometimes reinitialize useMemo calls after a hot update,
-    // causing the instance to be unexpectedly recreated in the middle of the components lifecycle.
+/**
+ * Returns an instance of the provided class,
+ * with the state and props arguments added as instance members.
+ *
+ * `state` must be an instance of `CleanState` created with {@link useCleanState}.
+ */
+var useMethods = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var Methods = args[0], _a = args[1], props = _a === void 0 ? {} : _a, state = args[2];
+    // 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.
+    // @todo Provide a way for users to reflect updated methods code on the existing instance after HMR.
     var methods = (0, react_1.useRef)((0, react_1.useMemo)(function () {
-        // See useLogic implementation for a discussion of this type assertion.
         return new Methods();
     }, [])).current;
-    methods.state = state;
-    methods.props = props;
+    /** A proxy variable to allow typechecking of the assignment to methods.props despite the need for "readonly" error suppression. */
+    var _propsProxy_;
+    // @ts-expect-error
+    methods.props = (_propsProxy_ = props);
+    if (state)
+        methods.state = state;
     return methods;
 };
 exports.useMethods = useMethods;
-testing: {
-    var a = function () { return __awaiter(void 0, void 0, void 0, function () {
-        var a, MyMethods, useCleanState, self;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    a = { b: '' };
-                    MyMethods = /** @class */ (function (_super) {
-                        __extends(MyMethods, _super);
-                        function MyMethods() {
-                            return _super !== null && _super.apply(this, arguments) || this;
-                        }
-                        return MyMethods;
-                    }(ComponentMethods));
-                    ;
-                    return [4 /*yield*/, import('./state.js')];
-                case 1:
-                    useCleanState = (_a.sent()).useCleanState;
-                    self = (0, exports.useMethods)(MyMethods, useCleanState({}), {});
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-}
+/*testing: {
+    let a = async () => {
+        const a: object = {b: ''};
+
+        type t = keyof typeof a;
+
+        class MyMethods extends ComponentMethods<WeakEmptyObject, null> {
+            // static getInitialState = () => ({});
+        };
+
+        const { useCleanState } = (await import('./state.js'));
+
+        const self = useMethods(MyMethods, {});
+        self.state;
+    }
+}*/

package/build/base/state.d.ts

@@ -1,3 +1,4 @@
+import '../globals';
 /**
  * Returns a value that is false before the component has been mounted,
  * then true during all subsequent rerenders.
@@ -7,8 +8,8 @@ type PutState<TState extends object> = {
     [Key in keyof TState]: React.Dispatch<React.SetStateAction<TState[Key]>>;
 };
 declare class CleanStateBase<TState extends Record<string, any>> {
-    reservedKeys: string[];
-    valueKeys: string[];
+    readonly reservedKeys: string[];
+    readonly valueKeys: string[];
     private _values_;
     private _initialValues_;
     private _setters_;
@@ -16,14 +17,20 @@ declare class CleanStateBase<TState extends Record<string, any>> {
     static update: <TState_1 extends object>(this: CleanStateBase<TState_1>) => void;
     get put(): PutState<TState>;
     get initialState(): TState;
-    putMany: (newValues: Partial<TState>) => void;
+    readonly putMany: (newValues: Partial<TState>) => void;
 }
-type TCleanStateInstance<TState extends object> = TState & CleanStateBase<TState>;
-export type TCleanState<TState extends object> = TCleanStateInstance<TState>;
-export type TState<YourCleanState extends CleanStateBase<{}>> = Omit<YourCleanState, keyof CleanStateBase<{}>>;
+export type TStateData = object & {
+    [Key in keyof CleanStateBase<{}>]?: never;
+};
+export type TCleanState<TState extends TStateData> = (CleanStateBase<TState> & Omit<TState, keyof CleanStateBase<{}>>);
+export type ExtractCleanStateData<YourCleanState extends CleanStateBase<{}>> = Omit<YourCleanState, keyof CleanStateBase<{}>>;
 type StateInitFunction = (...args: any[]) => object;
 type StateInit = object | StateInitFunction;
 type TInitialState<Initializer extends StateInit> = Initializer extends (...args: any[]) => (infer TState extends object) ? TState : Initializer;
-type TUseCleanState = <TInit extends StateInit>(_initialState: TInit, ...props: TInit extends (...args: infer TProps extends any[]) => (infer TState extends object) ? TProps : []) => TCleanStateInstance<TInitialState<TInit>>;
+type TUseCleanState = <TInit extends StateInit>(_initialState: TInit, ...props: TInit extends (...args: infer TProps extends any[]) => (infer TState extends object) ? TProps : []) => TCleanState<TInitialState<TInit>>;
+/**
+ * Creates a state object, which includes the provided values, and helper methods for
+ * updating those values and automatically rerendering your component's UI accordingly.
+ */
 export declare const useCleanState: TUseCleanState;
 export {};

package/build/base/state.js

@@ -12,6 +12,7 @@ var __assign = (this && this.__assign) || function () {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useCleanState = exports.useMountState = void 0;
+require("../globals");
 var react_1 = require("react");
 /**
  * Returns a value that is false before the component has been mounted,
@@ -117,22 +118,22 @@ var CleanStateBase = /** @class */ (function () {
 }());
 ;
 var CleanState = CleanStateBase;
+/**
+ * Creates a state object, which includes the provided values, and helper methods for
+ * updating those values and automatically rerendering your component's UI accordingly.
+ */
 var useCleanState = function (_initialState) {
     var props = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         props[_i - 1] = arguments[_i];
     }
-    var mounted = (0, exports.useMountState)();
     var initialState = typeof _initialState === 'function'
         ? (0, react_1.useMemo)(function () { return _initialState.apply(void 0, props); }, [])
         : _initialState;
     ;
-    var freshInstance = {};
-    if (!mounted)
-        freshInstance = new CleanState(initialState);
-    if (!freshInstance.put)
-        throw new Error('useCleanState failed to initialized a state instance.');
-    var cleanState = (0, react_1.useRef)(freshInstance).current;
+    var cleanState = (0, react_1.useRef)((0, react_1.useMemo)(function () {
+        return new CleanState(initialState);
+    }, [])).current;
     CleanState.update.call(cleanState);
     return cleanState;
 };

package/build/classy/class.d.ts

@@ -1,16 +1,117 @@
 import type { VoidFunctionComponent } from 'react';
+import type { TStateData } from '../base';
+import type { IComponentInstanceClass } from './instance';
 import { ComponentInstance } from './instance';
-type Extractor = <TComponent extends typeof ClassComponent<object, object, object>>(this: TComponent & Constructor<InstanceType<TComponent>>, _Component?: TComponent & Constructor<InstanceType<TComponent>>) => VoidFunctionComponent<InstanceType<TComponent>['props']>;
-export declare class ClassComponent<TState extends object = EmptyObject, TProps extends object = EmptyObject, THooks extends object = EmptyObject> extends ComponentInstance<TState, TProps, THooks> {
-    Render: VoidFunctionComponent<{}>;
-    static renderAs: 'component' | 'template';
-    static FC: Extractor;
+import { THooksBase } from './logic';
+export declare const useRerender: () => () => void;
+type ComponentClassParams = ConstructorParameters<typeof ClassComponent>;
+type o = object;
+export interface IComponentClass<Instance extends ClassComponent<o, o, THooksBase> = ClassComponent, Params extends ComponentClassParams = ComponentClassParams> extends IComponentInstanceClass<Instance, Params> {
+}
+type Extractor = <TComponent extends typeof ClassComponent<o, o, THooksBase>>(this: NonNullable<typeof _Component>, _Component?: TComponent & IComponentClass<InstanceType<TComponent>>) => VoidFunctionComponent<InstanceType<TComponent>['props']>;
+type ReactTemplate = React.JSX.Element | null;
+/**
+ * A superset of {@link ComponentInstance} that allows defining your
+ * component's JSX template directly inside the class.
+ *
+ * This is designed to closely resemble the old {@link React.Component} class,
+ * making it easier to migrate older class components to the newer hooks-based system
+ * with little to no changes to their existing semantics/implementation.
+ */
+export declare class ClassComponent<TProps extends o = WeakEmptyObject, TState extends TStateData = WeakEmptyObject, THooks extends THooksBase = void> extends ComponentInstance<TProps, TState, THooks> {
+    /**
+     * @deprecated An older alternative to {@link template}.
+     *
+     * Using this will add a component boundary between your JSX template
+     * and the function component returned from ClassComponent.FC();
+     *
+     * This means that from React's perspective, your template won't "own" the state and props it consumes.
+     * This could lead to subtle unexpected changes in behaviour.
+     *
+     * In most cases, you should use {@link template} instead, as it allows your class component
+     * to function more predictably as a single unit.
+     */
+    Render?: VoidFunctionComponent<{}>;
+    /**
+     * Analogous to {@link React.Component.render}. A function that returns
+     * your component's JSX template.
+     *
+     * You should place most logic that would usually go here
+     * in {@link ComponentInstance.beforeRender | `beforeRender`} instead.
+     * This helps to separate concerns and keep the template itself clean.
+     *
+     * ******
+     *
+     * Ideally the template method should only be concerned with defining the HTML/JSX structure of
+     * your component's UI. This may include destructuring nested instance members
+     * into more easily accessible local variables, or some simple transformation of data from props/state
+     * into a more appropriate format for display.
+     *
+     * ******
+     *
+     * @example < caption>Using a template function that returns JSX.</ caption>
+     *
+     * ```tsx
+     * template = () => {
+     *     const { title } = this.props;
+     *
+     *     return (
+     *         <h1>
+     *             {this.props.title}
+     *         </h1>
+     *     );
+     * }
+     * ```
+     */
+    template?: () => ReactTemplate;
+    /**
+     * Manually trigger a rerender of your component.
+     * You should rarely ever need this. But if you are migrating
+     * an older React.Component class, this should provide similar functionality
+     * to the {@link Component.forceUpdate | `forceUpdate`} method provided there.
+     *
+     * Note that the callback argument is currently not supported.
+     */
+    readonly forceUpdate: VoidFunction;
+    /*************************************
+     *   Function Component Extractor    *
+    **************************************/
+    /**
+     * Extract a function component which can be used to render
+     * your ClassComponent just like any other component.
+     *
+     * Each JSX reference to this returned component will render with
+     * a separate instance of your class.
+     *
+     * So you only need to call `YourClassComponent.FC()` once, then use the returned
+     * function component as many times as you need.
+     */
+    static readonly FC: Extractor;
 }
 interface HookWrapperProps<THookFunction extends AnyFunction> {
+    /**
+     * The React hook you which to consume.
+     * Render a separate instance of the `<Use />` component for each hook.
+     * You can also create a custom hook that combines multiple hooks,
+     * then use that wrapper hook with a single `<Use />` instance.
+     */
     hook: THookFunction;
+    /**
+     * An array containing the list of arguments
+     * to be passed to your hook, in the right order.
+     */
     argumentsList: Parameters<THookFunction>;
+    /**
+     * A callback that will be called with whatever value your hook returns.
+     * Use this to update your component's state with the value.
+     * This will allow your component to rerender whenever the hook returns a new value.
+     */
     onUpdate: (output: ReturnType<THookFunction>) => void;
 }
 type ClassComponentHookWrapper = <Hook extends AnyFunction>(props: HookWrapperProps<Hook>) => null;
+/**
+ * A component you can use to consume hooks
+ * in a {@link Component | React.Component} class component.
+ */
 export declare const Use: ClassComponentHookWrapper;
 export {};

package/build/classy/class.js

@@ -15,7 +15,7 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Use = exports.ClassComponent = void 0;
+exports.Use = exports.ClassComponent = exports.useRerender = void 0;
 var jsx_runtime_1 = require("react/jsx-runtime");
 var react_1 = require("react");
 var instance_1 = require("./instance");
@@ -32,22 +32,68 @@ var setFunctionName = function (func, newName) {
         console.warn(error);
     }
 };
-// eslint-enable no-use-before-define
+var useRerender = function () {
+    /*
+     * Skip the value, we don't need it.
+     * Grab just the setter function.
+     */
+    var _a = (0, react_1.useState)(Date.now()), _forceRerender = _a[1];
+    var rerender = function () { return _forceRerender(Date.now()); };
+    return rerender;
+};
+exports.useRerender = useRerender;
+;
+/**
+ * A superset of {@link ComponentInstance} that allows defining your
+ * component's JSX template directly inside the class.
+ *
+ * This is designed to closely resemble the old {@link React.Component} class,
+ * making it easier to migrate older class components to the newer hooks-based system
+ * with little to no changes to their existing semantics/implementation.
+ */
 var ClassComponent = /** @class */ (function (_super) {
     __extends(ClassComponent, _super);
     function ClassComponent() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    ClassComponent.renderAs = 'component';
+    /*************************************
+     *   Function Component Extractor    *
+    **************************************/
+    // @todo Attempt using implicit `this` value to allow rendering <MyComponent.FC /> directly.
+    // const FC = (props) => { const self = useMemo(() => useInstance(this, props), {}); return self.template(); }
+    /**
+     * Extract a function component which can be used to render
+     * your ClassComponent just like any other component.
+     *
+     * Each JSX reference to this returned component will render with
+     * a separate instance of your class.
+     *
+     * So you only need to call `YourClassComponent.FC()` once, then use the returned
+     * function component as many times as you need.
+     */
     ClassComponent.FC = function FC(_Component) {
         var Component = _Component !== null && _Component !== void 0 ? _Component : this;
         var isClassComponentType = Component.prototype instanceof ClassComponent;
         if (!Component.getInitialState || !isClassComponentType)
             throw new Error('Attempted to initialize ClassComponent with invalid Class type. Either pass a class that extends ClassComponent to FC (e.g `export FC(MyComponent);`), or ensure it is called as a method on a ClassComponent constructor type (e.g `export MyComponent.FC()`).');
-        var Wrapper = function (props, context) {
-            var Render = (0, instance_1.useInstance)(Component, props).Render;
+        /*************************************
+         *    Begin Function Component       *
+        **************************************/
+        /** A class-based React function component created with (@cleanweb/react).ClassComponent */
+        var Wrapper = function (props) {
+            var instance = (0, instance_1.useInstance)(Component, props);
+            var Render = instance.Render, template = instance.template;
+            var _forceUpdate;
+            // @ts-expect-error (Cannot assign to 'forceUpdate' because it is a read-only property.ts(2540))
+            instance.forceUpdate = (_forceUpdate = (0, exports.useRerender)() // Moved this to separate line to allow TS errors. Use proxy local variable to regain some type checking for the assignment to `instance.forceUpdate`.
+            );
             // Add calling component name to Render function name in stack traces.
-            (0, react_1.useMemo)(function () { return setFunctionName(Render, "".concat(Component.name, ".Render")); }, [Render]);
+            (0, react_1.useMemo)(function () {
+                if (typeof template === 'function')
+                    setFunctionName(template, "".concat(Component.name, ".template"));
+                else if (typeof Render === 'function')
+                    setFunctionName(Render, "".concat(Component.name, ".Render"));
+            }, [Render, template]);
             /**
              * Normally a component can update it's own state in the "before-render" stage to
              * skip DOM updates and trigger and immediate rerun of the rendering with the new state.
@@ -58,28 +104,48 @@ var ClassComponent = /** @class */ (function (_super) {
              * state in the "before-render" stage of `Render`, since it will be attempting to update it's parent's
              * state (i.e `Wrapper` component) rather than it's own state.
              *
-             * Consider using this as a function call instead of JSX to avoid that. This way, we avoid
+             * Users should favor using the `template()` method instead. This way, we avoid
              * establishing a component boundary between `Wrapper` and `Render`.
              *
              * Although, since beforeRender() is called earlier from a hook, this is probably
              * a non-issue. It will only force users to move their logic into `beforeRender` instead
-             * of doing it directly in `Render`. This might mean cleaner Render functions,
-             * so there's probably no real value lost if we keep the component boundary.
+             * of doing it directly in `Render`. Even if `template` is being used, the `beforeRender` method
+             * is the preferred location for such logic to maintain a high level of separation of concerns,
+             * which is what this library exists to provide.
+             *
+             * So there's probably no real value lost with the component boundary. Users should just use
+             * `beforeRender` + `template`.
             **/
-            if (Component.renderAs === 'template')
-                return Render({}, context);
-            // With the existence of useContext(),
-            // what exactly does the context argument to FunctionComponent represent?
-            // Do we need to find a way to pass that context value to <Render /> here?
-            return (0, jsx_runtime_1.jsx)(Render, {});
+            switch (typeof template) {
+                case 'undefined':
+                    if (typeof Render === 'function')
+                        return (0, jsx_runtime_1.jsx)(Render, {});
+                    else
+                        throw new Error([
+                            'A ClassComponent must have either a `template` or a `Render` property. But neither was found.',
+                            'Add a `template: (JSX.Element | null);` member to your class, (or a `template` method that returns the same type).',
+                            'Alternatively, add a `Render: FunctionComponent;` method.',
+                            '\n\n',
+                            'Expected `Render` to be a Function Component because `template` was `undefined`.',
+                            "Instead got the following '".concat(typeof Render, "': $o"),
+                        ].join(' '), Render);
+                case 'function': return template();
+                default: return template;
+            }
         };
-        // Include calling component name in wrapper function name on stack traces.
-        setFunctionName(Wrapper, "".concat(Component.name, " < Wrapper")); // ${Wrapper.name}
+        /*************************************
+         *     End Function Component        *
+        **************************************/
+        setFunctionName(Wrapper, "$".concat(Component.name, "$"));
         return Wrapper;
     };
     return ClassComponent;
 }(instance_1.ComponentInstance));
 exports.ClassComponent = ClassComponent;
+/**
+ * A component you can use to consume hooks
+ * in a {@link Component | React.Component} class component.
+ */
 var Use = function (params) {
     var useGenericHook = params.hook, argumentsList = params.argumentsList, onUpdate = params.onUpdate;
     var output = useGenericHook.apply(void 0, argumentsList);

package/build/classy/instance.d.ts

@@ -1,7 +1,15 @@
+import type { TStateData } from '../base/state';
+import type { THooksBase, IComponentLogicClass } from './logic';
 import { ComponentLogic } from './logic';
 type AsyncAllowedEffectCallback = () => Awaitable<IVoidFunction>;
+/** An empty function. It returns (void) without performing any operations. */
 export declare const noOp: () => void;
-export declare class ComponentInstance<TState extends object = EmptyObject, TProps extends object = EmptyObject, THooks extends object = EmptyObject> extends ComponentLogic<TState, TProps, THooks> {
+/**
+ * A superset of {@link ComponentLogic} that adds support for special lifecycle methods.
+ * This provides a declarative API for working with your React function component's lifecycle,
+ * a simpler alternative to the imperative approach with `useEffect` and/or `useMemo`.
+ */
+export declare class ComponentInstance<TProps extends o = {}, TState extends TStateData = WeakEmptyObject, THooks extends THooksBase = void> extends ComponentLogic<TProps, TState, THooks> {
     /**
      * Runs only _before_ first render, i.e before the component instance is mounted.
      * Useful for logic that is involved in determining what to render.
@@ -46,17 +54,13 @@ export declare class ComponentInstance<TState extends object = EmptyObject, TPro
      */
     cleanUp: IVoidFunction;
 }
-type UseInstance = <TClass extends typeof ComponentInstance<object, object, object>>(Class: TClass & Constructor<InstanceType<TClass>>, ...props: valueof<InstanceType<TClass>['props']> extends never ? ([] | [EmptyObject] | [InstanceType<TClass>['props']]) : [InstanceType<TClass>['props']]) => InstanceType<TClass>;
-/**
- * To ensure successful type checking, the second parameter must be written with spread syntax.
- * Likely because of the `exactOptionalPropertyTypes` config option turned on,
- * and `UseInstance` using an empty tuple in its rest parameter type, attempting to simply
- * retrieve the second argument directly causes an error when that argument is passed on to `useLogic`.
- * But directly working with the rest array bypasses the problem. Also note that the issue persists even when
- * the second param is given `{}` as a default follow to account for the empty tuple case. TypeScript
- * just wants us to use the rest parameter explicitly by force.
- */
+type o = object;
+type InstanceClassParams = ConstructorParameters<typeof ComponentInstance<o, o, o>>;
+export interface IComponentInstanceClass<Instance extends ComponentInstance<o, o, THooksBase> = ComponentInstance, Params extends InstanceClassParams = InstanceClassParams> extends IComponentLogicClass<Instance, Params> {
+}
+type UseInstance = {
+    <Class extends typeof ComponentInstance<HardEmptyObject, o, THooksBase>>(Methods: Class & IComponentInstanceClass<InstanceType<Class>>): InstanceType<Class>;
+    <Class extends typeof ComponentInstance<o, o, THooksBase>>(Methods: Class & IComponentInstanceClass<InstanceType<Class>>, props: InstanceType<Class>['props']): InstanceType<Class>;
+};
 export declare const useInstance: UseInstance;
-type UseMountCallbacks = <TInstance extends ComponentInstance<any, any, any>>(instance: TInstance) => void;
-export declare const useMountCallbacks: UseMountCallbacks;
 export {};

package/build/classy/instance.js

@@ -14,22 +14,44 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-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.useMountCallbacks = exports.useInstance = exports.ComponentInstance = exports.noOp = void 0;
+exports.useInstance = exports.ComponentInstance = exports.noOp = void 0;
 var react_1 = require("react");
 var state_1 = require("../base/state");
 var logic_1 = require("./logic");
+var useMountCallbacks = function (instance) {
+    var _a;
+    var mounted = (0, state_1.useMountState)();
+    if (!mounted)
+        (_a = instance.beforeMount) === null || _a === void 0 ? void 0 : _a.call(instance);
+    (0, react_1.useEffect)(function () {
+        var _a;
+        var mountHandlerCleanUp = (_a = instance.onMount) === null || _a === void 0 ? void 0 : _a.call(instance);
+        return function () {
+            var doCleanUp = function (runMountCleaners) {
+                var _a;
+                runMountCleaners === null || runMountCleaners === void 0 ? void 0 : runMountCleaners();
+                // onDismount? willUnmount?
+                (_a = instance.cleanUp) === null || _a === void 0 ? void 0 : _a.call(instance);
+            };
+            if (typeof mountHandlerCleanUp === 'function') {
+                doCleanUp(mountHandlerCleanUp);
+            }
+            else {
+                mountHandlerCleanUp === null || mountHandlerCleanUp === void 0 ? void 0 : mountHandlerCleanUp.then(doCleanUp);
+            }
+        };
+    }, []);
+};
+/** An empty function. It returns (void) without performing any operations. */
 var noOp = function () { };
 exports.noOp = noOp;
+// @todo Use rollup. Insert globals.ts reference tag to all d.ts output files.
+/**
+ * A superset of {@link ComponentLogic} that adds support for special lifecycle methods.
+ * This provides a declarative API for working with your React function component's lifecycle,
+ * a simpler alternative to the imperative approach with `useEffect` and/or `useMemo`.
+ */
 var ComponentInstance = /** @class */ (function (_super) {
     __extends(ComponentInstance, _super);
     function ComponentInstance() {
@@ -83,7 +105,8 @@ var ComponentInstance = /** @class */ (function (_super) {
 }(logic_1.ComponentLogic));
 exports.ComponentInstance = ComponentInstance;
 ;
-/**
+;
+/*
  * To ensure successful type checking, the second parameter must be written with spread syntax.
  * Likely because of the `exactOptionalPropertyTypes` config option turned on,
  * and `UseInstance` using an empty tuple in its rest parameter type, attempting to simply
@@ -92,14 +115,15 @@ exports.ComponentInstance = ComponentInstance;
  * the second param is given `{}` as a default follow to account for the empty tuple case. TypeScript
  * just wants us to use the rest parameter explicitly by force.
  */
-var useInstance = function (Component) {
+var useInstance = function () {
     var _a;
     var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
     }
+    var Component = args[0], _b = args[1], props = _b === void 0 ? {} : _b;
     // useHooks.
-    var instance = logic_1.useLogic.apply(void 0, __spreadArray([Component], args, false)); // Must spread rest parameter, rather than passing a single `props` argument directly.
+    var instance = (0, logic_1.useLogic)(Component, props);
     /**
      * Argument of type '
         * [
@@ -115,8 +139,7 @@ var useInstance = function (Component) {
         '
      */
     // beforeMount, onMount, cleanUp.
-    // eslint-disable-next-line no-use-before-define
-    (0, exports.useMountCallbacks)(instance);
+    useMountCallbacks(instance);
     // beforeRender.
     (_a = instance.beforeRender) === null || _a === void 0 ? void 0 : _a.call(instance);
     // onRender.
@@ -133,28 +156,21 @@ var useInstance = function (Component) {
     return instance;
 };
 exports.useInstance = useInstance;
-var useMountCallbacks = function (instance) {
-    var _a;
-    var mounted = (0, state_1.useMountState)();
-    if (!mounted)
-        (_a = instance.beforeMount) === null || _a === void 0 ? void 0 : _a.call(instance);
-    (0, react_1.useEffect)(function () {
-        var _a;
-        var mountHandlerCleanUp = (_a = instance.onMount) === null || _a === void 0 ? void 0 : _a.call(instance);
-        return function () {
-            var doCleanUp = function (runMountCleaners) {
-                var _a;
-                runMountCleaners === null || runMountCleaners === void 0 ? void 0 : runMountCleaners();
-                // onDismount? willUnmount?
-                (_a = instance.cleanUp) === null || _a === void 0 ? void 0 : _a.call(instance);
-            };
-            if (typeof mountHandlerCleanUp === 'function') {
-                doCleanUp(mountHandlerCleanUp);
-            }
-            else {
-                mountHandlerCleanUp === null || mountHandlerCleanUp === void 0 ? void 0 : mountHandlerCleanUp.then(doCleanUp);
-            }
-        };
-    }, []);
-};
-exports.useMountCallbacks = useMountCallbacks;
+/*testing: {
+    class A extends ComponentInstance {
+        static getInitialState: (p?: object) => ({putan: ''});
+        // k = this.props.o
+        a = this.state['_initialValues_']
+
+        // hard empty has every key
+        // weak empty has no key
+        // weak empty is not assignable to hard empty
+    }
+
+    const p = {k: ''}
+    const a = useInstance(A, {o: ''});
+
+    // a.props['o'];
+    type bbbb = A['state'];
+    type ttt = bbbb['put'];
+}*/

package/build/classy/logic.d.ts

@@ -1,23 +1,57 @@
-import type { TCleanState, TState } from '../base/state';
+import type { TCleanState, ExtractCleanStateData, TStateData } from '../base/state';
+export type HardEmpty = HardEmptyObject;
+export type WeakEmpty = WeakEmptyObject;
+export type THooksBase = o | void;
 type o = object;
-export declare class ComponentLogic<TState_ extends object = EmptyObject, TProps extends object = EmptyObject, THooks extends object = EmptyObject> {
-    state: TCleanState<TState_>;
-    props: TProps;
-    hooks: THooks;
-    static getInitialState: <ThisT extends typeof ComponentLogic<o, o, o>>(this: ThisT, props?: InstanceType<ThisT>['props']) => TState<InstanceType<ThisT>['state']> & any;
-    useHooks?: () => THooks;
+/**
+ * Base class for a class that holds methods intended for use in a function component,
+ * as well as a static method for initializing state.
+ *
+ * These methods will have access to the components state and props via
+ * `this.state` and `this.props` respectively.
+ *
+ * The special {@link ComponentLogic.useHooks | useHooks} method allows you to consume
+ * React hooks within this class.
+ *
+ * Call the {@link useLogic} hook inside your function component to instantiate the class.
+ */
+export declare class ComponentLogic<
+/** Describe the values your component expects to be passed as props. */
+TProps extends object = {}, 
+/** An object type that descibes your component's state. */
+TState extends TStateData = WeakEmpty, 
+/** The object type returned by your component's {@link useHooks} method. */
+THooks extends THooksBase = void> {
+    state: TCleanState<TState>;
+    readonly props: TProps;
+    readonly hooks: THooks extends object ? THooks : WeakEmptyObject;
+    /**
+     * 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.
+     */
+    static getInitialState: (p?: any) => object;
+    /**
+     * This allows you to seamlessly consume React hooks in
+     * your class component.
+     *
+     * It is called after state and props are updated on each render.
+     * Call any hooks (e.g `useEffect`) you which to consume inside this function.
+     *
+     * To expose any returned values from your hooks to the rest of your component,
+     * return an object that contains all the relevant values.
+     *
+     * This object will be accessible as `this.hooks` to the rest of your class.
+     */
+    useHooks: THooks extends void ? undefined | (() => void | HardEmptyObject) : () => THooks;
 }
-type CnstPrm = ConstructorParameters<typeof ComponentLogic>;
-export interface IComponentClass<Instance extends ComponentLogic = ComponentLogic> {
-    new (...params: CnstPrm): Instance;
-    getInitialState: (props?: Instance['props']) => TState<Instance['state']>;
+type LogicClassParams = ConstructorParameters<typeof ComponentLogic>;
+export interface IComponentLogicClass<Instance extends ComponentLogic<o, o, THooksBase> = ComponentLogic, Params extends LogicClassParams = LogicClassParams> extends Constructor<Instance, Params> {
+    getInitialState: (props?: Instance['props']) => ExtractCleanStateData<Instance['state']>;
 }
-export type ComponentClassStatics<Instance extends ComponentLogic<object, object, object>> = {
-    getInitialState: (props?: Instance['props']) => TState<Instance['state']>;
+type UseLogic = {
+    <Class extends typeof ComponentLogic<HardEmptyObject, o, THooksBase>>(Methods: Class & IComponentLogicClass<InstanceType<Class>>): InstanceType<Class>;
+    <Class extends typeof ComponentLogic<o, o, THooksBase>>(Methods: Class & IComponentLogicClass<InstanceType<Class>>, props: InstanceType<Class>['props']): InstanceType<Class>;
 };
-export type TComponentClass<Instance extends ComponentLogic<object, object, object>, Statics extends ComponentClassStatics<Instance> = ComponentClassStatics<Instance>, Params extends CnstPrm = CnstPrm> = Statics & Constructor<Instance, Params>;
-export interface IEmpty extends EmptyObject {
-}
-type UseLogic = <Class extends typeof ComponentLogic<object, object, object>, Instance extends InstanceType<Class> = InstanceType<Class>>(Methods: Class & Constructor<Instance>, ...props: valueof<Instance['props']> extends never ? ([] | [EmptyObject] | [Instance['props']]) : [Instance['props']]) => Instance;
-export declare const useLogic: UseLogic;
-export {};
+declare const useLogic: UseLogic;
+export { useLogic };

package/build/classy/logic.js

@@ -1,67 +1,81 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var _a;
 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 intended for use in a function component,
+ * as well as a static method for initializing state.
+ *
+ * These methods will have access to the components state and props via
+ * `this.state` and `this.props` respectively.
+ *
+ * The special {@link ComponentLogic.useHooks | useHooks} method allows you to consume
+ * React hooks within this class.
+ *
+ * Call the {@link useLogic} hook inside your function component to instantiate the class.
+ */
 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.
+     */
+    ComponentLogic.getInitialState = function (p) { return ({}); };
     return ComponentLogic;
 }());
 exports.ComponentLogic = ComponentLogic;
 ;
-testing: {
-    var A = (_a = /** @class */ (function (_super) {
-            __extends(C, _super);
-            function C() {
-                return _super !== null && _super.apply(this, arguments) || this;
-            }
-            return C;
-        }(ComponentLogic)),
-        _a.getInitialState = function () { return ({}); },
-        _a);
-    A.getInitialState();
-}
-;
-var useLogic = function (Methods, props) {
-    var _b;
-    if (props === void 0) { props = {}; }
-    var state = (0, state_1.useCleanState)(Methods.getInitialState, props);
-    var methods = (0, react_1.useRef)((0, react_1.useMemo)(function () {
-        return new Methods();
+var useLogic = function () {
+    var _a, _b;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var Logic = args[0], _c = args[1], props = _c === void 0 ? {} : _c;
+    var state = (0, state_1.useCleanState)(Logic.getInitialState, props);
+    var self = (0, react_1.useRef)((0, react_1.useMemo)(function () {
+        return new Logic();
     }, [])).current;
-    methods.state = state;
-    methods.props = props;
-    methods.hooks = ((_b = methods.useHooks) === null || _b === void 0 ? void 0 : _b.call(methods)) || {};
-    return methods;
+    /** A proxy variable to allow typechecking of the assignment to `self.props` despite the need for "readonly" error suppression. */
+    var _propsProxy_;
+    /** A proxy variable to allow typechecking of the assignment to `self.hooks` despite the need for "readonly" error suppression. */
+    var _hooksProxy_;
+    self.state = state;
+    // @ts-expect-error
+    self.props = (_propsProxy_ = props);
+    // @ts-expect-error
+    self.hooks = (_hooksProxy_ = (_b = (_a = self.useHooks) === null || _a === void 0 ? void 0 : _a.call(self)) !== null && _b !== void 0 ? _b : {} // @todo Improve UseLogic types to reflect that this may be undefined.
+    );
+    return self;
 };
 exports.useLogic = useLogic;
-testing: {
-    var a = { b: '' };
-    var MyComponentLogic = /** @class */ (function (_super) {
-        __extends(MyComponentLogic, _super);
-        function MyComponentLogic() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        MyComponentLogic.getInitialState = function () { return ({}); };
-        return MyComponentLogic;
-    }(ComponentLogic));
-    ;
-    var self_1 = (0, exports.useLogic)(MyComponentLogic);
-}
+/*testing: {
+    const a: object = {b: ''};
+
+    type t = keyof typeof a;
+
+    class MyComponentLogic extends ComponentLogic<{a: string}> {
+        static getInitialState = () => ({a: '' as const});
+        // b = this.state.put[''] + this.props.b;
+    };
+
+    type tt = keyof {};
+
+    MyComponentLogic.getInitialState
+    // const self = useLogic(MyComponentLogic);
+
+
+    const A = class C extends ComponentLogic {
+        // static getInitialState = () => ({a: 'l'});
+        // a = () => this.state.yyy = '';
+    }
+
+    A.getInitialState();
+
+    // const oa = {['a' as unknown as symbol]: 'boo'};
+    const oa = {['a']: 'boo'};
+    // const self = useLogic(A, oa);
+}*/

package/build/globals.d.ts

@@ -1,24 +1,4 @@
-/**
- * @file
- * This file is an "Ambient declarations file". The types defined here are available globally.
- * More info here: https://stackoverflow.com/a/73389225/985454
- *
- * Don't use `import` and `export` in this file directly! It breaks ambience.
- * To import external types in an ambient declarations file (this file) use the following:
- *
- * @example
- * declare type React = typeof import('react');
- *
- * To contribute ambient declarations from any file, even non-ambient ones, use this:
- *
- * @example
- * declare global {
- *   interface Window {
- *     ethereum: any
- *   }
- * }
-**/
-/** */
+declare const UniqueSecretSymbolKey: unique symbol;
 declare global {
     type Optional<BaseType, AllowNull extends boolean = true> = (AllowNull extends true ? BaseType | undefined | null : BaseType | undefined);
     type Awaitable<Type> = Type | Promise<Type>;
@@ -42,6 +22,15 @@ declare global {
     type AnyFunction = (...args: any) => any;
     type FunctionType = AnyFunction;
     type TFunction = AnyFunction;
+    type NotNullish = {};
+    type NonPrimitive = object;
+    interface WeakEmptyObject {
+        [UniqueSecretSymbolKey]?: never;
+    }
+    interface HardEmptyObject {
+        [key: keyof any]: never;
+    }
+    type valueof<TObject> = TObject[keyof TObject];
     interface Window {
     }
     namespace JSX {
@@ -52,16 +41,5 @@ declare global {
         interface ProcessEnv {
         }
     }
-    type __FromPrivateHelpers = typeof import('./globals.private');
-    type TEmptyObject1 = {
-        ''?: never;
-    };
-    type TEmptyObject2 = Record<symbol, never>;
-    type EmptyObject = __FromPrivateHelpers['EmptyObject'];
-    type EmptyObject2 = __FromPrivateHelpers['EmptyObject2'];
-    type EmptyObject3 = __FromPrivateHelpers['EmptyObject3'];
-    type valueof<TObject> = TObject[keyof TObject];
-    interface T extends __FromPrivateHelpers {
-    }
 }
 export {};

package/build/globals.js

@@ -1,22 +1,4 @@
 "use strict";
-/**
- * @file
- * This file is an "Ambient declarations file". The types defined here are available globally.
- * More info here: https://stackoverflow.com/a/73389225/985454
- *
- * Don't use `import` and `export` in this file directly! It breaks ambience.
- * To import external types in an ambient declarations file (this file) use the following:
- *
- * @example
- * declare type React = typeof import('react');
- *
- * To contribute ambient declarations from any file, even non-ambient ones, use this:
- *
- * @example
- * declare global {
- *   interface Window {
- *     ethereum: any
- *   }
- * }
-**/
 Object.defineProperty(exports, "__esModule", { value: true });
+/////////////
+var UniqueSecretSymbolKey = Symbol('asdfghjkliuytrewqaxcvb,nb');

package/build/index.d.ts

@@ -1 +1 @@
-export * from "./classy";
+export * from './classy';

package/build/index.js

@@ -16,7 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./classy"), exports);
 // PS: Document component inheritance pattern with lifecycle callback arrays and namespaces.
-// Due to react's remounting behaviour, components must externally track when some logic has run, if it really really must only ever run once per mounted instance. Tricky to get right for components that may have multiple instance rendered simultaneously at different parts of a page.
+// Due to react's remounting behaviour, components must externally track when some logic has run,
+// if it really really must only ever run once per mounted instance. Tricky to get right for components that may have multiple instance rendered simultaneously at different parts of a page.
 // useCleanState => useState, separate call for each key
 // useMergedState => useState, same call for all keys
 // useMethods => useCallback

package/build/tsconfig.json

@@ -32,13 +32,15 @@
 		"noImplicitAny": true,
 		"noUncheckedIndexedAccess": true,
 		"strictBindCallApply": true,
-		// "exactOptionalPropertyTypes": true
+		"exactOptionalPropertyTypes": true,
 	},
 	"include": [
+		// "**/[!globals].ts",
 		"**/*.ts",
 		"**/*.tsx"
 	],
 	"exclude": [
+		"**/globals.ts",
 		"node_modules/**/**.*",
 		"build/**/**.*",
 		"mirror-pkg/**/**.*"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleanweb/react",
-  "version": "1.1.1-beta.2",
+  "version": "1.1.1-beta.21",
   "description": "A suite of helpers for writing cleaner React function components.",
   "engines": {
     "node": ">=18"
@@ -30,7 +30,7 @@
   "scripts": {
     "prebuild": "rimraf ./build",
     "build": "tsc && tsc-alias",
-    "postbuild": "copyfiles globals.d.ts tsconfig.json build",
+    "postbuild": "copyfiles tsconfig.json build",
     "_": "",
     "prepublishOnly": "npm run build",
     "publish:patch": "npm version patch && npm publish",

package/build/globals.private.d.ts

@@ -1,48 +0,0 @@
-/**
- * @file
- * This file is created specifically to augment the declarations in
- * [globals.d.ts]({@link ./globals.d.ts}).
- *
- * **You should not import this file directly.**
- */
-/** */
-declare const UniqueSecretSymbolKey: unique symbol;
-declare class CEmptyObject {
-    [key: keyof any]: never;
-}
-declare class CEmptyObject2 {
-    [UniqueSecretSymbolKey]?: never;
-}
-declare class CEmptyObject3 {
-    /**
-     * 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;
-}
-export declare const EmptyObject: CEmptyObject;
-export declare const EmptyObject2: CEmptyObject2;
-export declare const EmptyObject3: CEmptyObject3;
-export {};

package/build/globals.private.js

@@ -1,40 +0,0 @@
-"use strict";
-/**
- * @file
- * This file is created specifically to augment the declarations in
- * [globals.d.ts]({@link ./globals.d.ts}).
- *
- * **You should not import this file directly.**
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmptyObject3 = exports.EmptyObject2 = exports.EmptyObject = void 0;
-/** */
-var UniqueSecretSymbolKey = Symbol('asdfghjkliuytrewqaxcvb,nb');
-var CEmptyObject = /** @class */ (function () {
-    function CEmptyObject() {
-    }
-    return CEmptyObject;
-}());
-var CEmptyObject2 = /** @class */ (function () {
-    function CEmptyObject2() {
-    }
-    return CEmptyObject2;
-}());
-var CEmptyObject3 = /** @class */ (function () {
-    function CEmptyObject3() {
-    }
-    return CEmptyObject3;
-}());
-exports.EmptyObject = new CEmptyObject();
-exports.EmptyObject2 = new CEmptyObject2();
-exports.EmptyObject3 = new CEmptyObject3();
-testing: {
-    var mySymbol = Symbol('asdfgh');
-    var tt = {
-    // [mySymbol]: '' as never,
-    // [UniqueSecretSymbolKey]: '',
-    // '': '',
-    };
-    var TT = new CEmptyObject();
-    TT = tt;
-}