@cleanweb/react 1.1.1-beta.20 → 1.1.1-beta.23

package/build/base/merged-state.js

@@ -71,9 +71,9 @@ var MergedState = /** @class */ (function () {
     return MergedState;
 }());
 var useMergedState = function (initialState) {
-    var cleanState = (0, react_1.useMemo)(function () {
+    var cleanState = (0, react_1.useRef)((0, react_1.useMemo)(function () {
         return new MergedState(initialState);
-    }, []);
+    }, [])).current;
     MergedState.useRefresh.call(cleanState);
     return cleanState;
 };

package/build/base/methods.d.ts

@@ -23,3 +23,19 @@ type UseMethods = {
  */
 declare const useMethods: UseMethods;
 export { useMethods };
+/** /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/methods.js

@@ -46,7 +46,7 @@ var useMethods = function () {
     return methods;
 };
 exports.useMethods = useMethods;
-/*testing: {
+/** /testing: {
     let a = async () => {
         const a: object = {b: ''};
 
@@ -61,4 +61,4 @@ exports.useMethods = useMethods;
         const self = useMethods(MyMethods, {});
         self.state;
     }
-}*/
+}/**/

package/build/classy/class.d.ts

@@ -4,12 +4,15 @@ import type { IComponentInstanceClass } from './instance';
 import { ComponentInstance } from './instance';
 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 ComponentClassOwnStaticKeys = Exclude<keyof typeof ClassComponent, keyof IComponentInstanceClass>;
+type ComponentClassOwnStatics = {
+    [Key in ComponentClassOwnStaticKeys]: (typeof ClassComponent)[Key];
+};
+export interface IComponentClass<Instance extends ClassComponent<o, o, THooksBase> = ClassComponent> extends Constructor<Instance>, ComponentClassOwnStatics, IComponentInstanceClass<Instance> {
 }
-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;
+type BaseClassComponent = ClassComponent<o, o, THooksBase>;
+type Extractor = <TComponent extends IComponentClass<BaseClassComponent>>(this: NonNullable<typeof _Component>, _Component?: TComponent) => VoidFunctionComponent<InstanceType<TComponent>['props']>;
 /**
  * A superset of {@link ComponentInstance} that allows defining your
  * component's JSX template directly inside the class.
@@ -63,7 +66,7 @@ export declare class ClassComponent<TProps extends o = WeakEmptyObject, TState e
      * }
      * ```
      */
-    template?: () => ReactTemplate;
+    template?: () => (React.JSX.Element | null);
     /**
      * Manually trigger a rerender of your component.
      * You should rarely ever need this. But if you are migrating
@@ -77,16 +80,31 @@ export declare class ClassComponent<TProps extends o = WeakEmptyObject, TState e
      *   Function Component Extractor    *
     **************************************/
     /**
-     * Extract a function component which can be used to render
-     * your ClassComponent just like any other component.
+     * Extract a Function Component (FC) which can be used to render
+     * your ClassComponent just like any other React component.
      *
-     * Each JSX reference to this returned component will render with
+     * Each JSX reference to the 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.
+     *
+     * It is recommended to store this returned value as a static member of
+     * your ClassComponent. While this value may be given any name, the name
+     * RC (for "React Component") is the recommended convention.
+     *
+     * @example <caption>Calling FC in your ClassComponent</caption>
+     * class Button extends ClassComponent {
+     *     static readonly RC = this.FC();
+     *     // Because of the static keyword, `this` here refers to the class itself, same as calling `Button.FC()`.
+     * }
+     *
+     * // Render with `<Button.RC />`, or export RC to use the component in other files.
+     * export default Button.RC;
      */
     static readonly FC: Extractor;
+    /** @see {@link ClassComponent.FC} */
+    static readonly extract: Extractor;
 }
 interface HookWrapperProps<THookFunction extends AnyFunction> {
     /**
@@ -115,3 +133,19 @@ type ClassComponentHookWrapper = <Hook extends AnyFunction>(props: HookWrapperPr
  */
 export declare const Use: ClassComponentHookWrapper;
 export {};
+/** /testing: {
+    const a: object = {b: ''};
+
+    type t = keyof typeof a;
+
+    class MyComponentLogic extends ClassComponent<{}, {a: ''}> {
+        static getInitialState = () => ({a: '' as const});
+        // a = () => this.hooks.a = '';
+
+        useHooks = () => {
+            this.state.a;
+        };
+    };
+
+    const Template = MyComponentLogic.FC();
+}/**/

package/build/classy/class.js

@@ -56,24 +56,37 @@ var ClassComponent = /** @class */ (function (_super) {
     function ClassComponent() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    var _a;
+    _a = ClassComponent;
     /*************************************
      *   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.
+     * Extract a Function Component (FC) which can be used to render
+     * your ClassComponent just like any other React component.
      *
-     * Each JSX reference to this returned component will render with
+     * Each JSX reference to the 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.
+     *
+     * It is recommended to store this returned value as a static member of
+     * your ClassComponent. While this value may be given any name, the name
+     * RC (for "React Component") is the recommended convention.
+     *
+     * @example <caption>Calling FC in your ClassComponent</caption>
+     * class Button extends ClassComponent {
+     *     static readonly RC = this.FC();
+     *     // Because of the static keyword, `this` here refers to the class itself, same as calling `Button.FC()`.
+     * }
+     *
+     * // Render with `<Button.RC />`, or export RC to use the component in other files.
+     * export default Button.RC;
      */
     ClassComponent.FC = function FC(_Component) {
         var Component = _Component !== null && _Component !== void 0 ? _Component : this;
-        var isClassComponentType = Component.prototype instanceof ClassComponent;
+        var isClassComponentType = Component.prototype instanceof _a;
         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()`).');
         /*************************************
@@ -139,6 +152,8 @@ var ClassComponent = /** @class */ (function (_super) {
         setFunctionName(Wrapper, "$".concat(Component.name, "$"));
         return Wrapper;
     };
+    /** @see {@link ClassComponent.FC} */
+    ClassComponent.extract = _a.FC;
     return ClassComponent;
 }(instance_1.ComponentInstance));
 exports.ClassComponent = ClassComponent;

package/build/classy/instance.d.ts

@@ -1,5 +1,5 @@
-import type { TStateData } from '../base/state';
-import type { THooksBase, IComponentLogicClass } from './logic';
+import type { ExtractCleanStateData, TStateData } from '../base/state';
+import type { THooksBase } from './logic';
 import { ComponentLogic } from './logic';
 type AsyncAllowedEffectCallback = () => Awaitable<IVoidFunction>;
 /** An empty function. It returns (void) without performing any operations. */
@@ -9,7 +9,7 @@ export declare const noOp: () => void;
  * 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> {
+export declare class ComponentInstance<TProps extends o = {}, TState extends TStateData = WeakEmptyObject, THooks extends THooksBase = void> extends ComponentLogic.Class<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.
@@ -55,12 +55,36 @@ export declare class ComponentInstance<TProps extends o = {}, TState extends TSt
     cleanUp: IVoidFunction;
 }
 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 ComponentInstanceOwnStaticKeys = Exclude<keyof typeof ComponentInstance, keyof ComponentLogic.ClassType>;
+type ComponentInstanceOwnStatics = {
+    [Key in ComponentInstanceOwnStaticKeys]: (typeof ComponentInstance)[Key];
+};
+export interface IComponentInstance<Instance extends ComponentInstance<o, o, THooksBase>> extends ComponentLogic.Instance<Instance>, Omit<ComponentInstance<Instance['props'], ExtractCleanStateData<Instance['state']>, Instance['_thooks']>, 'useHooks'> {
+}
+export interface IComponentInstanceClass<Instance extends ComponentInstance<o, o, THooksBase> = ComponentInstance> extends Constructor<IComponentInstance<Instance>>, ComponentInstanceOwnStatics, ComponentLogic.ClassType<Instance> {
 }
 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>;
+    <Class extends IComponentInstanceClass<ComponentInstance<o, o, THooksBase>>>(Methods: Class): InstanceType<Class>;
+    <Class extends IComponentInstanceClass<ComponentInstance<o, o, THooksBase>>>(Methods: Class, props: InstanceType<Class>['props']): InstanceType<Class>;
 };
 export declare const useInstance: UseInstance;
 export {};
+/** /testing: {
+    class A extends ComponentInstance<{}, {}, object> {
+        static getInitialState: (p?: object) => ({putan: ''});
+        // k = this.props.o
+        a = this.state['_initialValues_']
+
+        // useHooks: (() => void | HardEmptyObject) | undefined;
+        // hard empty has every key
+        // weak empty has no key
+        // weak empty is not assignable to hard empty
+    }
+
+    const a = useInstance(A, {o: ''});
+    a.a;
+
+    // a.props['o'];
+    type bbbb = A['state'];
+    type ttt = bbbb['put'];
+}/**/

package/build/classy/instance.js

@@ -102,7 +102,7 @@ var ComponentInstance = /** @class */ (function (_super) {
         return _this;
     }
     return ComponentInstance;
-}(logic_1.ComponentLogic));
+}(logic_1.ComponentLogic.Class));
 exports.ComponentInstance = ComponentInstance;
 ;
 ;
@@ -156,21 +156,22 @@ var useInstance = function () {
     return instance;
 };
 exports.useInstance = useInstance;
-/*testing: {
-    class A extends ComponentInstance {
+/** /testing: {
+    class A extends ComponentInstance<{}, {}, object> {
         static getInitialState: (p?: object) => ({putan: ''});
         // k = this.props.o
         a = this.state['_initialValues_']
 
+        // useHooks: (() => void | HardEmptyObject) | undefined;
         // 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.a;
 
     // a.props['o'];
     type bbbb = A['state'];
     type ttt = bbbb['put'];
-}*/
+}/**/

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

@@ -0,0 +1,18 @@
+import type { ComponentLogic } from '.';
+import type { CLBaseType, IComponentLogic } from './instance-types';
+import type { IComponentLogicClass } from './static-types';
+/*************************************
+ *        # Hooks                    *
+**************************************/
+/** */
+type ULClassParam = IComponentLogicClass<IComponentLogic<CLBaseType>>;
+export type UseLogic = {
+    <Class extends ULClassParam>(Methods: Class): InstanceType<Class>;
+    <Class extends ULClassParam>(Methods: Class, props: InstanceType<Class>['props']): InstanceType<Class>;
+};
+export type ULParams = [
+    Class: ComponentLogic.ClassType<ComponentLogic.Instance<CLBaseType>>,
+    props?: object
+];
+export type ULReturn = CLBaseType;
+export {};

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

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

package/build/classy/logic/index.d.ts

@@ -0,0 +1,77 @@
+import type { TCleanState, TStateData } from '../../base/state';
+import type { IComponentLogicClass } from './static-types';
+import type { CLBaseType, IComponentLogic } from './instance-types';
+import type { UseLogic } from './hook-types';
+export type HardEmpty = HardEmptyObject;
+export type WeakEmpty = WeakEmptyObject;
+export type THooksBase = object | void;
+/**
+ * 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 Class['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<TProps extends object = {}, TState extends TStateData = WeakEmpty, THooks extends THooksBase = void> {
+    readonly 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.
+     *
+     * PS: `p?: object` wierdly causes TS error in v^5.5.4; object is not assignable to the component's TProps.
+     */
+    static getInitialState: (p?: any) => object;
+    /** Do not use. Will be undefined at runtime. */
+    readonly _thooks: THooks;
+    /**
+     * Call React hooks and expose any values your component
+     * needs by return an object with said values. The returned
+     * object will be accessible as `this.hooks`;
+     */
+    useHooks: () => void;
+}
+export declare const useLogic: UseLogic;
+export declare namespace ComponentLogic {
+    class Class<TProps extends object = {}, TState extends TStateData = WeakEmpty, THooks extends THooksBase = void> extends ComponentLogic<TProps, TState, THooks> {
+    }
+    type Instance<Instance extends CLBaseType = Class> = IComponentLogic<Instance>;
+    type ClassType<Instance extends CLBaseType = Class> = IComponentLogicClass<Instance>;
+}
+/** /testing: {
+    const a: object = {b: ''};
+
+    type t = keyof typeof a;
+
+    class MyComponentLogic extends ComponentLogic.Class<{}, {b: number}, {a: string}> {
+        static getInitialState = () => ({b: 7});
+        // b = this.state.put[''] + this.props.b;
+
+        useHooks = () => ({a: 'undefined'});
+    };
+
+    type tt = keyof {};
+
+    MyComponentLogic.getInitialState
+    const self = useLogic(MyComponentLogic);
+    self.useHooks();
+
+
+    const A = class C extends ComponentLogic.Class {
+        // static getInitialState = () => ({a: 'l'});
+        // a = () => this.state.yyy = '';
+    }
+
+    A.getInitialState();
+
+    // const oa = {['a' as unknown as symbol]: 'boo'};
+    const oa = {['a']: 'boo'};
+    useLogic(A, oa);
+}/**/

package/build/classy/logic/index.js

@@ -0,0 +1,120 @@
+"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 __());
+    };
+})();
+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 Class['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() {
+        /**
+         * Call React hooks and expose any values your component
+         * needs by return an object with said values. The returned
+         * object will be accessible as `this.hooks`;
+         */
+        this.useHooks = function () { };
+    }
+    /**
+     * 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.
+     *
+     * PS: `p?: object` wierdly causes TS error in v^5.5.4; object is not assignable to the component's TProps.
+     */
+    ComponentLogic.getInitialState = function (p) { return ({}); };
+    return ComponentLogic;
+}());
+exports.ComponentLogic = ComponentLogic;
+;
+var useLogic = function () {
+    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;
+    var state = (0, state_1.useCleanState)(Logic.getInitialState, props);
+    var self = (0, react_1.useRef)((0, react_1.useMemo)(function () {
+        return new Logic();
+    }, [])).current;
+    /** 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.state` despite the need for "readonly" error suppression. */
+    var _stateProxy_;
+    /** A proxy variable to allow typechecking of the assignment to `self.hooks` despite the need for "readonly" error suppression. */
+    var _hooksProxy_;
+    // @ts-expect-error
+    self.props = (_propsProxy_ = props);
+    // @ts-expect-error
+    self.state = (_stateProxy_ = state);
+    // @ts-expect-error
+    self.hooks = (_hooksProxy_ = (_a = self.useHooks()) !== null && _a !== void 0 ? _a : {});
+    return self;
+};
+exports.useLogic = useLogic;
+(function (ComponentLogic) {
+    var Class = /** @class */ (function (_super) {
+        __extends(Class, _super);
+        function Class() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return Class;
+    }(ComponentLogic));
+    ComponentLogic.Class = Class;
+    ;
+})(ComponentLogic || (exports.ComponentLogic = ComponentLogic = {}));
+/** /testing: {
+    const a: object = {b: ''};
+
+    type t = keyof typeof a;
+
+    class MyComponentLogic extends ComponentLogic.Class<{}, {b: number}, {a: string}> {
+        static getInitialState = () => ({b: 7});
+        // b = this.state.put[''] + this.props.b;
+
+        useHooks = () => ({a: 'undefined'});
+    };
+
+    type tt = keyof {};
+
+    MyComponentLogic.getInitialState
+    const self = useLogic(MyComponentLogic);
+    self.useHooks();
+
+
+    const A = class C extends ComponentLogic.Class {
+        // static getInitialState = () => ({a: 'l'});
+        // a = () => this.state.yyy = '';
+    }
+
+    A.getInitialState();
+
+    // const oa = {['a' as unknown as symbol]: 'boo'};
+    const oa = {['a']: 'boo'};
+    useLogic(A, oa);
+}/**/

package/build/classy/logic/instance-types.d.ts

@@ -0,0 +1,19 @@
+import type { ExtractCleanStateData } from '../../base';
+import type { ComponentLogic, THooksBase } from '.';
+/*************************************
+ *        # Utils                    *
+**************************************/
+/** */
+export type CLBaseType = ComponentLogic<object, object, THooksBase>;
+type CLFromSubType<SubType extends CLBaseType> = ComponentLogic<SubType['props'], ExtractCleanStateData<SubType['state']>, SubType['_thooks']>;
+/*************************************
+ *        # Instance Type            *
+**************************************/
+/** */
+interface InstanceOverrides<Instance extends CLBaseType = ComponentLogic> {
+    useHooks: Instance['_thooks'] extends void ? () => (void | HardEmptyObject) : () => Instance['_thooks'];
+}
+type BaseInstance<Instance extends CLBaseType = ComponentLogic> = Omit<CLFromSubType<Instance>, keyof InstanceOverrides>;
+export interface IComponentLogic<Instance extends CLBaseType = ComponentLogic> extends BaseInstance<Instance>, InstanceOverrides<Instance> {
+}
+export {};

package/build/classy/logic/instance-types.js

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

package/build/classy/logic/static-types.d.ts

@@ -0,0 +1,17 @@
+import type { ExtractCleanStateData } from '../../base';
+import type { ComponentLogic, THooksBase } from '.';
+import type { CLBaseType } from './instance-types';
+/*************************************
+ *        # Utils                    *
+**************************************/
+type o = object;
+/*************************************
+ *        # Class Static Side        *
+**************************************/
+interface StaticOverrides<Instance extends CLBaseType = ComponentLogic> extends Constructor<Instance> {
+    getInitialState: (props?: Instance['props']) => ExtractCleanStateData<Instance['state']>;
+}
+type BaseStatics = Omit<typeof ComponentLogic, 'prototype' | keyof StaticOverrides>;
+export interface IComponentLogicClass<Instance extends ComponentLogic<o, o, THooksBase> = ComponentLogic> extends BaseStatics, StaticOverrides<Instance> {
+}
+export {};

package/build/classy/logic/static-types.js

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

package/build/globals.d.ts

@@ -1,4 +1,16 @@
 declare const UniqueSecretSymbolKey: unique symbol;
+/** /testing: {
+    const mySymbol = Symbol('asdfgh') as symbol;
+
+    const tt = {
+        // [mySymbol]: '' as never,
+        // [UniqueSecretSymbolKey]: '',
+        // '': '',
+    }
+
+    let TT: WeakEmptyObject = {};
+    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>;

package/build/tsconfig.json

@@ -29,6 +29,7 @@
 		"isolatedModules": true,
 		"jsx": "react-jsx",
 		"strictNullChecks": true,
+		"strictPropertyInitialization": true,
 		"noImplicitAny": true,
 		"noUncheckedIndexedAccess": true,
 		"strictBindCallApply": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cleanweb/react",
-  "version": "1.1.1-beta.20",
+  "version": "1.1.1-beta.23",
   "description": "A suite of helpers for writing cleaner React function components.",
   "engines": {
     "node": ">=18"

package/build/classy/logic.d.ts

@@ -1,57 +0,0 @@
-import type { TCleanState, ExtractCleanStateData, TStateData } from '../base/state';
-export type HardEmpty = HardEmptyObject;
-export type WeakEmpty = WeakEmptyObject;
-export type THooksBase = o | void;
-type o = object;
-/**
- * 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?: object) => 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 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']>;
-}
-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>;
-};
-declare const useLogic: UseLogic;
-export { useLogic };

package/build/classy/logic.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useLogic = exports.ComponentLogic = void 0;
-var react_1 = require("react");
-var state_1 = require("../base/state");
-/**
- * Base class for a class that holds methods 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;
-;
-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;
-    /** 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: {
-    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);
-}*/