@cleanweb/react 1.1.1-beta.13 → 1.1.1-beta.15

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> {
-    props: TProps;
-    state: TCleanState<TState>;
+export declare class ComponentMethods<TProps extends object = {}, TState extends TStateData | null = null> {
+    readonly props: TProps;
+    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,26 @@ 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;
+    /** 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;
@@ -91,7 +101,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/logic.d.ts

@@ -2,13 +2,12 @@ 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 = {}, TState extends TStateData = WeakEmpty, // WeakEmpty,
-THooks extends o = WeakEmpty> {
+export declare class ComponentLogic<TProps extends object = {}, TState extends TStateData = WeakEmpty, THooks extends object = {}> {
     state: TCleanState<TState>;
-    props: TProps;
-    hooks: THooks;
+    readonly props: TProps;
+    readonly hooks: THooks;
     static getInitialState: (p?: object) => object;
-    useHooks: THooks extends HardEmptyObject ? undefined | (() => HardEmptyObject | undefined) : () => THooks;
+    useHooks: THooks extends HardEmptyObject ? undefined | (() => THooks | void) : () => THooks;
 }
 type LogicClassParams = ConstructorParameters<typeof ComponentLogic>;
 export interface IComponentLogicClass<Instance extends ComponentLogic<o, o, o> = ComponentLogic, Params extends LogicClassParams = LogicClassParams> extends Constructor<Instance, Params> {

package/build/classy/logic.js

@@ -33,15 +33,22 @@ var useLogic = function () {
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
     }
-    var Methods = args[0], _c = args[1], props = _c === void 0 ? {} : _c;
-    var state = (0, state_1.useCleanState)(Methods.getInitialState, props);
-    var methods = (0, react_1.useRef)((0, react_1.useMemo)(function () {
-        return new Methods();
+    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 = (_a = methods.useHooks) === null || _a === void 0 ? void 0 : _a.call(methods)) !== null && _b !== void 0 ? _b : {};
-    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: {

package/package.json

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