@cleanweb/react 1.1.1-beta.4 → 1.1.1-beta.6

package/build/base/merged-state.js

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

package/build/base/methods.js

@@ -60,7 +60,7 @@ var ComponentMethods = /** @class */ (function () {
 }());
 exports.ComponentMethods = ComponentMethods;
 ;
-var useMethods = function (Methods, state, props) {
+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.
     // But useRef and useState values appear to always be preserved whenever this happens.
@@ -69,8 +69,8 @@ var useMethods = function (Methods, state, props) {
         // See useLogic implementation for a discussion of this type assertion.
         return new Methods();
     }, [])).current;
-    methods.state = state;
     methods.props = props;
+    methods.state = state;
     return methods;
 };
 exports.useMethods = useMethods;
@@ -92,7 +92,7 @@ testing: {
                     return [4 /*yield*/, import('./state.js')];
                 case 1:
                     useCleanState = (_a.sent()).useCleanState;
-                    self = (0, exports.useMethods)(MyMethods, useCleanState({}), {});
+                    self = (0, exports.useMethods)(MyMethods, {}, useCleanState({}));
                     return [2 /*return*/];
             }
         });

package/build/classy/class.d.ts

@@ -6,8 +6,9 @@ type o = object;
 export interface IComponentClass<Instance extends ClassComponent<o, o, o> = ClassComponent, Params extends ComponentClassParams = ComponentClassParams> extends IComponentInstanceClass<Instance, Params> {
 }
 type Extractor = <TComponent extends typeof ClassComponent<o, o, o>>(this: NonNullable<typeof _Component>, _Component?: TComponent & IComponentClass<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> {
+export declare class ClassComponent<TProps extends o = EmptyObject, TState extends o = EmptyObject, THooks extends o = EmptyObject> extends ComponentInstance<TState, TProps, THooks> {
     Render: VoidFunctionComponent<{}>;
+    readonly forceUpdate: VoidFunction;
     static renderAs: 'component' | 'template';
     static readonly FC: Extractor;
 }

package/build/classy/class.js

@@ -32,6 +32,15 @@ var setFunctionName = function (func, newName) {
         console.warn(error);
     }
 };
+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;
+};
 ;
 var ClassComponent = /** @class */ (function (_super) {
     __extends(ClassComponent, _super);
@@ -45,7 +54,12 @@ var ClassComponent = /** @class */ (function (_super) {
         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;
+            var instance = (0, instance_1.useInstance)(Component, props);
+            var Render = instance.Render;
+            var _forceUpdate;
+            // @ts-expect-error (Cannot assign to 'forceUpdate' because it is a read-only property.ts(2540))
+            instance.forceUpdate = (_forceUpdate = useRerender() // Moved this to separate line to allow TS errors. Use proxy local variable to regain some type checking for the assignment.
+            );
             // Add calling component name to Render function name in stack traces.
             (0, react_1.useMemo)(function () { return setFunctionName(Render, "".concat(Component.name, ".Render")); }, [Render]);
             /**

package/build/classy/instance.d.ts

@@ -3,7 +3,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<TState extends object = EmptyObject, TProps extends object = EmptyObject, THooks extends object = EmptyObject> extends ComponentLogic<TState, TProps, THooks> {
+export declare class ComponentInstance<TProps extends o = EmptyObject, TState extends o = EmptyObject, THooks extends o = EmptyObject> extends ComponentLogic<TState, TProps, 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.

package/build/classy/logic.d.ts

@@ -1,18 +1,17 @@
 import type { TCleanState, TState } from '../base/state';
 export type Empty = EmptyObject;
 type o = object;
-export declare class ComponentLogic<TState extends o = Empty, TProps extends o = Empty, THooks extends o = Empty> {
+export declare class ComponentLogic<TProps extends o = Empty, TState extends o = Empty, THooks extends o = Empty> {
     state: TCleanState<TState>;
     props: TProps;
     hooks: THooks;
-    static getInitialState: TBaseComponentLogic['getInitialState'];
+    static getInitialState: (p?: o) => {};
     useHooks?: () => THooks;
 }
 type LogicClassParams = ConstructorParameters<typeof ComponentLogic>;
 export interface IComponentLogicClass<Instance extends ComponentLogic<o, o, o> = ComponentLogic, Params extends LogicClassParams = LogicClassParams> extends Constructor<Instance, Params> {
     getInitialState: (props?: Instance['props']) => TState<Instance['state']>;
 }
-export type TBaseComponentLogic = IComponentLogicClass<ComponentLogic<any, any, any>>;
-type UseLogic = <Class extends TypeofClass & IComponentLogicClass<InstanceType<TypeofClass>>, TypeofClass extends typeof ComponentLogic<o, o, o>>(Methods: Class, ...props: valueof<InstanceType<Class>['props']> extends never ? ([] | [EmptyObject] | [InstanceType<Class>['props']]) : [InstanceType<Class>['props']]) => InstanceType<Class>;
+type UseLogic = <Class extends typeof ComponentLogic<o, o, o>>(Methods: Class & IComponentLogicClass<InstanceType<Class>>, ...props: valueof<InstanceType<Class>['props']> extends never ? ([] | [EmptyObject] | [InstanceType<Class>['props']]) : [InstanceType<Class>['props']]) => InstanceType<Class>;
 export declare const useLogic: UseLogic;
 export {};

package/build/classy/logic.js

@@ -14,21 +14,20 @@ var __extends = (this && this.__extends) || (function () {
         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");
-// React.Component
 var ComponentLogic = /** @class */ (function () {
     function ComponentLogic() {
     }
+    ComponentLogic.getInitialState = function (p) { return ({}); };
     return ComponentLogic;
 }());
 exports.ComponentLogic = ComponentLogic;
 ;
 var useLogic = function (Methods, props) {
-    var _b, _c;
+    var _a, _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 () {
@@ -36,7 +35,7 @@ var useLogic = function (Methods, props) {
     }, [])).current;
     methods.state = state;
     methods.props = props;
-    methods.hooks = (_c = (_b = methods.useHooks) === null || _b === void 0 ? void 0 : _b.call(methods)) !== null && _c !== void 0 ? _c : {};
+    methods.hooks = (_b = (_a = methods.useHooks) === null || _a === void 0 ? void 0 : _a.call(methods)) !== null && _b !== void 0 ? _b : {};
     return methods;
 };
 exports.useLogic = useLogic;
@@ -45,28 +44,30 @@ testing: {
     var MyComponentLogic = /** @class */ (function (_super) {
         __extends(MyComponentLogic, _super);
         function MyComponentLogic() {
-            return _super !== null && _super.apply(this, arguments) || this;
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.b = _this.state.a;
+            return _this;
         }
-        MyComponentLogic.getInitialState = function () { return ({}); };
+        MyComponentLogic.getInitialState = function (p) { return ({ a: '' }); };
         return MyComponentLogic;
     }(ComponentLogic));
     ;
-    var self_1 = (0, exports.useLogic)(MyComponentLogic);
+    MyComponentLogic.getInitialState;
+    var self_1 = (0, exports.useLogic)(MyComponentLogic, {});
 }
 testing: {
-    var A = (_a = /** @class */ (function (_super) {
-            __extends(C, _super);
-            function C() {
-                var _this = _super !== null && _super.apply(this, arguments) || this;
-                _this.b = _this.state.a;
-                return _this;
-            }
-            return C;
-        }(ComponentLogic)),
-        _a.getInitialState = function () { return ({ a: 'l' }); },
-        _a);
+    var A = /** @class */ (function (_super) {
+        __extends(C, _super);
+        function C() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            // static getInitialState = () => ({a: 'l'});
+            _this.b = _this.state.a;
+            return _this;
+        }
+        return C;
+    }(ComponentLogic));
     A.getInitialState();
-    // const self = useLogic(A);
+    var self_2 = (0, exports.useLogic)(A);
 }
 // export type ComponentClassStatics<Instance extends ComponentLogic<object, object, object>> = {
 // 	getInitialState: (props?: Instance['props']) => TState<Instance['state']>;

package/package.json

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