@cleanweb/react 1.1.1-beta.12 → 1.1.1-beta.14

package/build/base/methods.d.ts

@@ -1,8 +1,12 @@
 import type { TCleanState, TStateData } from './state';
-export declare class ComponentMethods<TProps extends object, TState extends TStateData> {
+export declare class ComponentMethods<TProps extends object = {}, TState extends TStateData | null = null> {
     props: TProps;
-    state: TCleanState<TState>;
+    state: TState extends TStateData ? TCleanState<TState> : null;
 }
-type UseMethods = <Class extends typeof ComponentMethods<object, object>>(Methods: Class & Constructor<InstanceType<Class>>, props: InstanceType<Class>['props'], state: InstanceType<Class>['state']) => InstanceType<Class>;
-export declare const useMethods: UseMethods;
-export {};
+type UseMethods = {
+    <Class extends typeof ComponentMethods<object, TStateData>>(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>;
+};
+declare const useMethods: UseMethods;
+export { useMethods };

package/build/base/methods.js

@@ -60,16 +60,23 @@ var ComponentMethods = /** @class */ (function () {
 }());
 exports.ComponentMethods = ComponentMethods;
 ;
-var useMethods = function (Methods, props, state) {
-    // @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.
+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 () {
         return new Methods();
     }, [])).current;
     methods.props = props;
-    methods.state = state;
+    if (state)
+        methods.state = state;
     return methods;
 };
 exports.useMethods = useMethods;
@@ -91,7 +98,8 @@ testing: {
                     return [4 /*yield*/, import('./state.js')];
                 case 1:
                     useCleanState = (_a.sent()).useCleanState;
-                    self = (0, exports.useMethods)(MyMethods, {}, useCleanState({}));
+                    self = useMethods(MyMethods, {});
+                    self.state;
                     return [2 /*return*/];
             }
         });

package/build/classy/instance.d.ts

@@ -4,7 +4,7 @@ type AsyncAllowedEffectCallback = () => Awaitable<IVoidFunction>;
 type UseMountCallbacks = <TInstance extends ComponentInstance<any, any, any>>(instance: TInstance) => void;
 export declare const useMountCallbacks: UseMountCallbacks;
 export declare const noOp: () => void;
-export declare class ComponentInstance<TProps extends o = WeakEmptyObject, TState extends TStateData = WeakEmptyObject, THooks extends o = WeakEmptyObject> extends ComponentLogic<TProps, TState, THooks> {
+export declare class ComponentInstance<TProps extends o = {}, TState extends TStateData = WeakEmptyObject, THooks extends o = WeakEmptyObject> 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.
@@ -54,7 +54,7 @@ type InstanceClassParams = ConstructorParameters<typeof ComponentInstance<o, o,
 export interface IComponentInstanceClass<Instance extends ComponentInstance<o, o, o> = ComponentInstance, Params extends InstanceClassParams = InstanceClassParams> extends IComponentLogicClass<Instance, Params> {
 }
 type UseInstance = {
-    <Class extends typeof ComponentInstance<HardEmptyObject, o, o>>(Methods: Class & IComponentInstanceClass<InstanceType<Class>>, props?: HardEmptyObject): InstanceType<Class>;
+    <Class extends typeof ComponentInstance<HardEmptyObject, o, o>>(Methods: Class & IComponentInstanceClass<InstanceType<Class>>): InstanceType<Class>;
     <Class extends typeof ComponentInstance<o, o, o>>(Methods: Class & IComponentInstanceClass<InstanceType<Class>>, props: InstanceType<Class>['props']): InstanceType<Class>;
 };
 export declare const useInstance: UseInstance;

package/build/classy/instance.js

@@ -117,7 +117,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 '
         * [
@@ -154,8 +154,16 @@ testing: {
     var A = /** @class */ (function (_super) {
         __extends(A, _super);
         function A() {
-            return _super !== null && _super.apply(this, arguments) || this;
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            // k = this.props.o
+            _this.a = _this.state['_initialValues_'];
+            return _this;
+            // hard empty has every key
+            // weak empty has no key
+            // weak empty is not assignable to hard empty
         }
         return A;
     }(ComponentInstance));
+    var p = { k: '' };
+    var a = (0, exports.useInstance)(A, { o: '' });
 }

package/build/classy/logic.d.ts

@@ -2,7 +2,7 @@ import type { TCleanState, ExtractCleanStateData, TStateData } from '../base/sta
 export type HardEmpty = HardEmptyObject;
 export type WeakEmpty = WeakEmptyObject;
 type o = object;
-export declare class ComponentLogic<TProps extends o = WeakEmpty, TState extends TStateData = WeakEmpty, // WeakEmpty,
+export declare class ComponentLogic<TProps extends o = {}, TState extends TStateData = WeakEmpty, // WeakEmpty,
 THooks extends o = WeakEmpty> {
     state: TCleanState<TState>;
     props: TProps;
@@ -15,7 +15,7 @@ export interface IComponentLogicClass<Instance extends ComponentLogic<o, o, o> =
     getInitialState: (props?: Instance['props']) => ExtractCleanStateData<Instance['state']>;
 }
 type UseLogic = {
-    <Class extends typeof ComponentLogic<HardEmptyObject, o, o>>(Methods: Class & IComponentLogicClass<InstanceType<Class>>, props?: HardEmptyObject): InstanceType<Class>;
+    <Class extends typeof ComponentLogic<HardEmptyObject, o, o>>(Methods: Class & IComponentLogicClass<InstanceType<Class>>): InstanceType<Class>;
     <Class extends typeof ComponentLogic<o, o, o>>(Methods: Class & IComponentLogicClass<InstanceType<Class>>, props: InstanceType<Class>['props']): InstanceType<Class>;
 };
 declare const useLogic: UseLogic;

package/package.json

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