@cleanweb/react 1.1.1-beta.8 → 2.0.1-beta.0

package/build/classy/{instance.js → instance/index.js}

@@ -15,37 +15,18 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useInstance = exports.ComponentInstance = exports.noOp = exports.useMountCallbacks = 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);
-            }
-        };
-    }, []);
-};
-exports.useMountCallbacks = useMountCallbacks;
+var logic_1 = require("../../classy/logic");
+var mount_callbacks_1 = require("./mount-callbacks");
+/** An empty function. It returns (void) without performing any operations. */
 var noOp = function () { };
 exports.noOp = noOp;
+/**
+ * A superset of {@link ComponentLogic} that adds support for 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() {
@@ -95,11 +76,17 @@ var ComponentInstance = /** @class */ (function (_super) {
         _this.cleanUp = function () { };
         return _this;
     }
+    Object.defineProperty(ComponentInstance.prototype, "templateContext", {
+        get: function () {
+            return this._templateContext;
+        },
+        enumerable: false,
+        configurable: true
+    });
     return ComponentInstance;
-}(logic_1.ComponentLogic));
+}(logic_1.ComponentLogic.Class));
 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,
@@ -117,7 +104,7 @@ var useInstance = function () {
     }
     var Component = args[0], _b = args[1], props = _b === void 0 ? {} : _b;
     // useHooks.
-    var instance = (0, logic_1.useLogic)(Component, props); // Must spread rest parameter, rather than passing a single `props` argument directly.
+    var instance = (0, logic_1.useLogic)(Component, props);
     /**
      * Argument of type '
         * [
@@ -133,9 +120,15 @@ var useInstance = function () {
         '
      */
     // beforeMount, onMount, cleanUp.
-    (0, exports.useMountCallbacks)(instance);
+    (0, mount_callbacks_1.useMountCallbacks)(instance);
     // beforeRender.
-    (_a = instance.beforeRender) === null || _a === void 0 ? void 0 : _a.call(instance);
+    /**
+     * A proxy variable to allow typechecking of the assignment
+     * to `self.templateContext` despite the need for "readonly" error suppression.
+     */
+    var _templateContextProxy_;
+    // @ts-expect-error
+    instance._templateContext = (_templateContextProxy_ = (_a = instance.beforeRender) === null || _a === void 0 ? void 0 : _a.call(instance));
     // onRender.
     (0, react_1.useEffect)(function () {
         var _a;
@@ -150,3 +143,39 @@ var useInstance = function () {
     return instance;
 };
 exports.useInstance = useInstance;
+(function (ComponentInstance) {
+    var Class = /** @class */ (function (_super) {
+        __extends(Class, _super);
+        function Class() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return Class;
+    }(ComponentInstance));
+    ComponentInstance.Class = Class;
+    ;
+})(ComponentInstance || (exports.ComponentInstance = ComponentInstance = {}));
+/** /
+testing: {
+    class A extends ComponentInstance<{}, {}> {
+        static getInitialState: (p?: object) => ({putan: ''});
+        // k = this.props.o
+        a = this.state['_initialValues_'];
+
+        beforeRender = () => '';
+
+        useHooks = () => {
+            type a = typeof this._templateContext;
+        };
+        // 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/mount-callbacks.d.ts

@@ -0,0 +1,4 @@
+import { CIBaseType, IComponentInstance } from './types/instance';
+type UseMountCallbacks = <TInstance extends IComponentInstance<CIBaseType>>(instance: TInstance) => void;
+export declare const useMountCallbacks: UseMountCallbacks;
+export {};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMountCallbacks = void 0;
+var react_1 = require("react");
+var state_1 = require("../../base/state");
+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;

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

@@ -0,0 +1,16 @@
+import type { CIBaseType, IComponentInstance } from './instance';
+import type { IComponentInstanceClass } from './static';
+import { ComponentInstance } from '..';
+type o = object;
+type UIClassParam = IComponentInstanceClass<IComponentInstance<CIBaseType>>;
+type UIProplessClassParam = IComponentInstanceClass<IComponentInstance<ComponentInstance<HardEmptyObject, o>>>;
+export type UseInstance = {
+    <Class extends UIProplessClassParam>(Methods: Class & Constructor<InstanceType<Class>>): InstanceType<Class>;
+    <Class extends UIClassParam>(Methods: Class & Constructor<InstanceType<Class>>, props: InstanceType<Class>['props']): InstanceType<Class>;
+};
+export type UIParams = [
+    Class: IComponentInstanceClass<IComponentInstance<CIBaseType>>,
+    props?: object
+];
+export type UIReturn = CIBaseType;
+export {};

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

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

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

@@ -0,0 +1,11 @@
+import type { InstanceOverrides as CLInstanceOverrides } from '../../../classy/logic/types/instance';
+import type { ExtractCleanStateData } from '../../../base';
+import { ComponentInstance } from '../../../classy/instance';
+export type CIBaseType = Omit<ComponentInstance<object, object>, never>;
+type CIFromSubType<SubType extends CIBaseType> = ComponentInstance<SubType['props'], ExtractCleanStateData<SubType['state']>>;
+export interface InstanceOverrides<Instance extends CIBaseType = ComponentInstance> extends CLInstanceOverrides<Instance> {
+}
+type BaseInstance<Instance extends CIBaseType = ComponentInstance> = Omit<CIFromSubType<Instance>, keyof InstanceOverrides>;
+export interface IComponentInstance<Instance extends CIBaseType = ComponentInstance> extends BaseInstance<Instance>, InstanceOverrides<Instance> {
+}
+export {};

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

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

package/build/classy/instance/types/static.d.ts

@@ -0,0 +1,11 @@
+import type { StaticOverrides as CLStaticOverrides } from '../../../classy/logic/types/static';
+import type { CIBaseType } from './instance';
+import { ComponentInstance } from '../../../classy/instance';
+/** */
+export interface StaticOverrides<Instance extends CIBaseType = ComponentInstance> extends CLStaticOverrides<Instance> {
+}
+type BaseStatics = Omit<typeof ComponentInstance, 'prototype' | keyof StaticOverrides>;
+export interface IComponentInstanceClass<Instance extends CIBaseType = ComponentInstance> extends BaseStatics, StaticOverrides<Instance> {
+}
+export {};
+/** */

package/build/classy/instance/types/static.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** */
+// type ComponentInstanceOwnStaticKeys = Exclude<
+// 	keyof typeof ComponentInstance,
+// 	keyof ComponentLogic.ClassType
+// >;
+// type ComponentInstanceOwnStatics = {
+// 	[Key in ComponentInstanceOwnStaticKeys]: (typeof ComponentInstance)[Key];
+// }
+// export interface IComponentInstanceClass<
+// 	Instance extends ComponentInstance<o, o> = ComponentInstance,
+// > extends
+// 	Constructor<IComponentInstance<Instance>>,
+// 	ComponentInstanceOwnStatics,
+// 	ComponentLogic.ClassType<Instance>
+// {};

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

@@ -0,0 +1,42 @@
+import type { TCleanState, TStateData } from '../../base/state';
+import type { IComponentLogicClass } from './types/static';
+import type { CLBaseType, IComponentLogic } from './types/instance';
+import type { UseLogic } from './types/hook';
+export type HardEmpty = HardEmptyObject;
+export type WeakEmpty = WeakEmptyObject;
+/**
+ * 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> {
+    readonly state: TCleanState<TState>;
+    readonly props: TProps;
+    readonly hooks: ReturnType<this['useHooks']>;
+    /**
+     * 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;
+    /**
+     * Call React hooks and expose any values your component
+     * needs by returning an object with said values. The returned
+     * object will be accessible as `this.hooks`;
+     */
+    useHooks: () => object | void;
+}
+export declare const useLogic: UseLogic;
+export declare namespace ComponentLogic {
+    class Class<TProps extends object = {}, TState extends TStateData = WeakEmpty> extends ComponentLogic<TProps, TState> {
+    }
+    type Instance<Instance extends CLBaseType = Class> = IComponentLogic<Instance>;
+    type ClassType<Instance extends CLBaseType = Class> = IComponentLogicClass<Instance>;
+}

package/build/classy/logic/index.js

@@ -0,0 +1,122 @@
+"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 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() {
+        // * PS: `p?: object` wierdly causes TS error in v^5.5.4; object is not assignable to the component's TProps.
+        /**
+         * Call React hooks and expose any values your component
+         * needs by returning 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.
+     */
+    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: {
+    var a = { b: '' };
+    var MyComponentLogic = /** @class */ (function (_super) {
+        __extends(MyComponentLogic, _super);
+        function MyComponentLogic() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            // b = this.state.put[''] + this.props.b;
+            _this.useHooks = function () { return ({ a: 'undefined' }); };
+            return _this;
+        }
+        MyComponentLogic.getInitialState = function () { return ({ b: 7 }); };
+        return MyComponentLogic;
+    }(ComponentLogic.Class));
+    ;
+    MyComponentLogic.getInitialState;
+    var self_1 = (0, exports.useLogic)(MyComponentLogic);
+    self_1.hooks;
+    self_1.useHooks();
+    var A = /** @class */ (function (_super) {
+        __extends(C, _super);
+        function C() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return C;
+    }(ComponentLogic.Class));
+    A.getInitialState();
+    // const oa = {['a' as unknown as symbol]: 'boo'};
+    var oa = (_a = {}, _a['a'] = 'boo', _a);
+    (0, exports.useLogic)(A, oa);
+}
+/**/

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

@@ -0,0 +1,24 @@
+import type { ComponentLogic } from '..';
+import type { CLBaseType, IComponentLogic } from './instance';
+import type { IComponentLogicClass } from './static';
+/*************************************
+ *        # Utils                    *
+**************************************/
+/** */
+type o = object;
+/*************************************
+ *        # Hooks                    *
+**************************************/
+/** */
+type ULClassParam = IComponentLogicClass<IComponentLogic<CLBaseType>>;
+type ULProplessClassParam = IComponentLogicClass<IComponentLogic<ComponentLogic<HardEmptyObject, o>>>;
+export type UseLogic = {
+    <Class extends ULProplessClassParam>(Methods: Class & Constructor<IComponentLogic<InstanceType<Class>>>): InstanceType<Class>;
+    <Class extends ULClassParam>(Methods: Class & Constructor<IComponentLogic<InstanceType<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/types/hook.js

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

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

@@ -0,0 +1,18 @@
+import type { ExtractCleanStateData } from '../../../base';
+import type { ComponentLogic } from '../../../classy/logic';
+/*************************************
+ *        # Utils                    *
+**************************************/
+/** */
+export type CLBaseType = ComponentLogic<object, object>;
+type CLFromSubType<SubType extends CLBaseType> = ComponentLogic<SubType['props'], ExtractCleanStateData<SubType['state']>>;
+/*************************************
+ *        # Instance Type            *
+**************************************/
+/** */
+export interface InstanceOverrides<Instance extends CLBaseType = ComponentLogic> {
+}
+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/types/instance.js

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

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

@@ -0,0 +1,17 @@
+import type { ExtractCleanStateData } from '../../../base';
+import type { ComponentLogic } from '../../../classy/logic';
+import type { CLBaseType } from './instance';
+/*************************************
+ *        # Utils                    *
+**************************************/
+type o = object;
+/*************************************
+ *        # Class Static Side        *
+**************************************/
+export 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> = ComponentLogic> extends BaseStatics, StaticOverrides<Instance> {
+}
+export {};

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

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

package/build/globals.d.ts

@@ -1,24 +1,16 @@
-/**
- * @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;
+/** /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>;
@@ -37,11 +29,20 @@ declare global {
      * 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 : Promise<void> | void;
+        (): AsyncType extends 'async' ? Promise<void> : AsyncType extends 'sync' ? void : void | Promise<void>;
     }
     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 +53,5 @@ declare global {
         interface ProcessEnv {
         }
     }
-    type __FromPrivateHelpers = typeof import('./globals.private');
-    type TEmptyObject1 = {
-        ''?: never;
-    };
-    type TEmptyObject2 = Record<symbol, never>;
-    type EmptyObject = __FromPrivateHelpers['EmptyObject2'];
-    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

@@ -29,16 +29,19 @@
 		"isolatedModules": true,
 		"jsx": "react-jsx",
 		"strictNullChecks": true,
+		"strictPropertyInitialization": true,
 		"noImplicitAny": true,
 		"noUncheckedIndexedAccess": true,
 		"strictBindCallApply": 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.8",
+  "version": "2.0.1-beta.0",
   "description": "A suite of helpers for writing cleaner React function components.",
   "engines": {
     "node": ">=18"
@@ -22,15 +22,17 @@
     "./state": "./build/base/state.js",
     "./state/merged": "./build/base/merged-state.js",
     "./methods": "./build/base/methods.js",
-    "./logic": "./build/classy/logic.js",
-    "./instance": "./build/classy/instance.js",
-    "./class-component": "./build/classy/class.js",
-    "./full-class": "./build/classy/class.js"
+    "./logic": "./build/classy/logic/index.js",
+    "./logic/*": "./build/classy/logic/*.js",
+    "./instance": "./build/classy/instance/index.js",
+    "./instance/*": "./build/classy/instance/*.js",
+    "./class": "./build/classy/class/index.js",
+    "./class/*": "./build/classy/class/*.js"
   },
   "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",