@cleanweb/react 1.1.1-beta.16 → 1.1.1-beta.18

package/build/base/methods.d.ts

@@ -1,4 +1,11 @@
 import type { TCleanState, TStateData } from './state';
+/**
+ * Base class for a class that holds methods intended for use in a function component.
+ * These methods will have access to the components state and props via
+ * `this.state` and `this.props` respectively.
+ *
+ * Call the {@link useMethods} hook inside your function component to instantiate the class.
+ */
 export declare class ComponentMethods<TProps extends object = {}, TState extends TStateData | null = null> {
     readonly props: TProps;
     state: TState extends TStateData ? TCleanState<TState> : null;
@@ -8,5 +15,11 @@ type UseMethods = {
     <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>;
 };
+/**
+ * Returns an instance of the provided class,
+ * with the state and props arguments added as instance members.
+ *
+ * `state` must be an instance of `CleanState` created with {@link useCleanState}.
+ */
 declare const useMethods: UseMethods;
 export { useMethods };

package/build/base/methods.js

@@ -1,58 +1,15 @@
 "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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMethods = exports.ComponentMethods = void 0;
+// Values
 var react_1 = require("react");
+/**
+ * Base class for a class that holds methods intended for use in a function component.
+ * These methods will have access to the components state and props via
+ * `this.state` and `this.props` respectively.
+ *
+ * Call the {@link useMethods} hook inside your function component to instantiate the class.
+ */
 var ComponentMethods = /** @class */ (function () {
     function ComponentMethods() {
     }
@@ -60,6 +17,12 @@ var ComponentMethods = /** @class */ (function () {
 }());
 exports.ComponentMethods = ComponentMethods;
 ;
+/**
+ * Returns an instance of the provided class,
+ * with the state and props arguments added as instance members.
+ *
+ * `state` must be an instance of `CleanState` created with {@link useCleanState}.
+ */
 var useMethods = function () {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -83,28 +46,19 @@ var useMethods = function () {
     return methods;
 };
 exports.useMethods = useMethods;
-testing: {
-    var a = function () { return __awaiter(void 0, void 0, void 0, function () {
-        var a, MyMethods, useCleanState, self;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    a = { b: '' };
-                    MyMethods = /** @class */ (function (_super) {
-                        __extends(MyMethods, _super);
-                        function MyMethods() {
-                            return _super !== null && _super.apply(this, arguments) || this;
-                        }
-                        return MyMethods;
-                    }(ComponentMethods));
-                    ;
-                    return [4 /*yield*/, import('./state.js')];
-                case 1:
-                    useCleanState = (_a.sent()).useCleanState;
-                    self = useMethods(MyMethods, {});
-                    self.state;
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-}
+/*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/state.d.ts

@@ -28,5 +28,9 @@ type StateInitFunction = (...args: any[]) => object;
 type StateInit = object | StateInitFunction;
 type TInitialState<Initializer extends StateInit> = Initializer extends (...args: any[]) => (infer TState extends object) ? TState : Initializer;
 type TUseCleanState = <TInit extends StateInit>(_initialState: TInit, ...props: TInit extends (...args: infer TProps extends any[]) => (infer TState extends object) ? TProps : []) => TCleanState<TInitialState<TInit>>;
+/**
+ * Creates a state object, which includes the provided values, and helper methods for
+ * updating those values and automatically rerendering your component's UI accordingly.
+ */
 export declare const useCleanState: TUseCleanState;
 export {};

package/build/base/state.js

@@ -118,6 +118,10 @@ var CleanStateBase = /** @class */ (function () {
 }());
 ;
 var CleanState = CleanStateBase;
+/**
+ * Creates a state object, which includes the provided values, and helper methods for
+ * updating those values and automatically rerendering your component's UI accordingly.
+ */
 var useCleanState = function (_initialState) {
     var props = [];
     for (var _i = 1; _i < arguments.length; _i++) {

package/build/classy/class.d.ts

@@ -8,19 +8,108 @@ 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 Extractor = <TComponent extends typeof ClassComponent<o, o, o>>(this: NonNullable<typeof _Component>, _Component?: TComponent & IComponentClass<InstanceType<TComponent>>) => VoidFunctionComponent<InstanceType<TComponent>['props']>;
+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;
+/**
+ * A superset of {@link ComponentInstance} that allows defining your
+ * component's JSX template directly inside the class.
+ *
+ * This is designed to closely resemble the old {@link React.Component} class,
+ * making it easier to migrate older class components to the newer hooks-based system
+ * with little to no changes to their existing semantics/implementation.
+ */
 export declare class ClassComponent<TProps extends o = WeakEmptyObject, TState extends TStateData = WeakEmptyObject, THooks extends THooksBase = void> extends ComponentInstance<TProps, TState, THooks> {
+    /**
+     * @deprecated An older alternative to {@link template}.
+     *
+     * Using this will add a component boundary between your JSX template
+     * and the function component returned from ClassComponent.FC();
+     *
+     * This means that from React's perspective, your template won't "own" the state and props it consumes.
+     * This could lead to subtle unexpected changes in behaviour.
+     *
+     * In most cases, you should use {@link template} instead, as it allows your class component
+     * to function more predictably as a single unit.
+     */
     Render?: VoidFunctionComponent<{}>;
+    /**
+     * Your components JSX template. This a variable that should represent what you
+     * would normally return from a regular function component.
+     *
+     * Alternatively, it can be a function that returns the required JSX.
+     * The function form is useful if your template references many nested instance members
+     * and you would like to destructure them into more easily accessible local variables.
+     *
+     * Besides that, you should place all other logic in {@link ComponentInstance.beforeRender | `beforeRender`}
+     * in order to separate concerns and keep the template itself clean.
+     *
+     * @example <caption>Using a simple JSX template</caption>
+     * template = (
+     *     <h1>
+     *         {this.props.title}
+     *     </h1>
+     * );
+     *
+     * @example <caption>Using a template function that returns JSX.</caption>
+     * template = () => {
+     *     const { title } = this.props;
+     *
+     *     return (
+     *         <h1>
+     *             {this.props.title}
+     *         </h1>
+     *     );
+     * }
+     */
     template?: ReactTemplate | (() => ReactTemplate);
+    /**
+     * Manually trigger a rerender of your component.
+     * You should rarely ever need this. But if you are migrating
+     * an older React.Component class, this should provide similar functionality
+     * to the {@link Component.forceUpdate | `forceUpdate`} method provided there.
+     *
+     * Note that the callback argument is currently not supported.
+     */
     readonly forceUpdate: VoidFunction;
+    /*************************************
+     *   Function Component Extractor    *
+    **************************************/
+    /**
+     * Extract a function component which can be used to render
+     * your ClassComponent just like any other component.
+     *
+     * Each JSX reference to this 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.
+     */
     static readonly FC: Extractor;
 }
 interface HookWrapperProps<THookFunction extends AnyFunction> {
+    /**
+     * The React hook you which to consume.
+     * Render a separate instance of the `<Use />` component for each hook.
+     * You can also create a custom hook that combines multiple hooks,
+     * then use that wrapper hook with a single `<Use />` instance.
+     */
     hook: THookFunction;
+    /**
+     * An array containing the list of arguments
+     * to be passed to your hook, in the right order.
+     */
     argumentsList: Parameters<THookFunction>;
+    /**
+     * A callback that will be called with whatever value your hook returns.
+     * Use this to update your component's state with the value.
+     * This will allow your component to rerender whenever the hook returns a new value.
+     */
     onUpdate: (output: ReturnType<THookFunction>) => void;
 }
 type ClassComponentHookWrapper = <Hook extends AnyFunction>(props: HookWrapperProps<Hook>) => null;
+/**
+ * A component you can use to consume hooks
+ * in a {@link Component | React.Component} class component.
+ */
 export declare const Use: ClassComponentHookWrapper;
 export {};

package/build/classy/class.js

@@ -43,16 +43,43 @@ var useRerender = function () {
 };
 exports.useRerender = useRerender;
 ;
+/**
+ * A superset of {@link ComponentInstance} that allows defining your
+ * component's JSX template directly inside the class.
+ *
+ * This is designed to closely resemble the old {@link React.Component} class,
+ * making it easier to migrate older class components to the newer hooks-based system
+ * with little to no changes to their existing semantics/implementation.
+ */
 var ClassComponent = /** @class */ (function (_super) {
     __extends(ClassComponent, _super);
     function ClassComponent() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /*************************************
+     *   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.
+     *
+     * Each JSX reference to this 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.
+     */
     ClassComponent.FC = function FC(_Component) {
         var Component = _Component !== null && _Component !== void 0 ? _Component : this;
         var isClassComponentType = Component.prototype instanceof ClassComponent;
         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()`).');
+        /*************************************
+         *    Begin Function Component       *
+        **************************************/
+        /** A class-based React function component created with (@cleanweb/react).ClassComponent */
         var Wrapper = function (props) {
             var instance = (0, instance_1.useInstance)(Component, props);
             var Render = instance.Render, template = instance.template;
@@ -106,13 +133,19 @@ var ClassComponent = /** @class */ (function (_super) {
                 default: return template;
             }
         };
-        // Include calling component name in wrapper function name on stack traces.
+        /*************************************
+         *     End Function Component        *
+        **************************************/
         setFunctionName(Wrapper, "$".concat(Component.name, "$"));
         return Wrapper;
     };
     return ClassComponent;
 }(instance_1.ComponentInstance));
 exports.ClassComponent = ClassComponent;
+/**
+ * A component you can use to consume hooks
+ * in a {@link Component | React.Component} class component.
+ */
 var Use = function (params) {
     var useGenericHook = params.hook, argumentsList = params.argumentsList, onUpdate = params.onUpdate;
     var output = useGenericHook.apply(void 0, argumentsList);
@@ -122,16 +155,3 @@ var Use = function (params) {
     return null;
 };
 exports.Use = Use;
-testing: {
-    var a = { b: '' };
-    var MyComponentLogic = /** @class */ (function (_super) {
-        __extends(MyComponentLogic, _super);
-        function MyComponentLogic() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        MyComponentLogic.getInitialState = function () { return ({ a: '' }); };
-        return MyComponentLogic;
-    }(ClassComponent));
-    ;
-    var Template = MyComponentLogic.FC();
-}

package/build/classy/instance.d.ts

@@ -2,9 +2,13 @@ import type { TStateData } from '../base/state';
 import type { THooksBase, IComponentLogicClass } from './logic';
 import { ComponentLogic } from './logic';
 type AsyncAllowedEffectCallback = () => Awaitable<IVoidFunction>;
-type UseMountCallbacks = <TInstance extends ComponentInstance<any, any, any>>(instance: TInstance) => void;
-export declare const useMountCallbacks: UseMountCallbacks;
+/** An empty function. It returns (void) without performing any operations. */
 export declare const noOp: () => void;
+/**
+ * A superset of {@link ComponentLogic} that adds support for special 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`.
+ */
 export declare class ComponentInstance<TProps extends o = {}, TState extends TStateData = WeakEmptyObject, THooks extends THooksBase = void> extends ComponentLogic<TProps, TState, THooks> {
     /**
      * Runs only _before_ first render, i.e before the component instance is mounted.

package/build/classy/instance.js

@@ -15,7 +15,7 @@ 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");
@@ -43,10 +43,15 @@ var useMountCallbacks = function (instance) {
         };
     }, []);
 };
-exports.useMountCallbacks = useMountCallbacks;
+/** An empty function. It returns (void) without performing any operations. */
 var noOp = function () { };
 exports.noOp = noOp;
 // @todo Use rollup. Insert globals.ts reference tag to all d.ts output files.
+/**
+ * A superset of {@link ComponentLogic} that adds support for special 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() {
@@ -134,7 +139,7 @@ var useInstance = function () {
         '
      */
     // beforeMount, onMount, cleanUp.
-    (0, exports.useMountCallbacks)(instance);
+    useMountCallbacks(instance);
     // beforeRender.
     (_a = instance.beforeRender) === null || _a === void 0 ? void 0 : _a.call(instance);
     // onRender.
@@ -151,20 +156,21 @@ var useInstance = function () {
     return instance;
 };
 exports.useInstance = useInstance;
-testing: {
-    var A = /** @class */ (function (_super) {
-        __extends(A, _super);
-        function A() {
-            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: '' });
-}
+/*testing: {
+    class A extends ComponentInstance {
+        static getInitialState: (p?: object) => ({putan: ''});
+        // k = this.props.o
+        a = this.state['_initialValues_']
+
+        // 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.props['o'];
+    type bbbb = A['state'];
+    type ttt = bbbb['put'];
+}*/

package/build/classy/logic.d.ts

@@ -3,11 +3,46 @@ export type HardEmpty = HardEmptyObject;
 export type WeakEmpty = WeakEmptyObject;
 export type THooksBase = o | void;
 type o = object;
-export declare class ComponentLogic<TProps extends object = {}, TState extends TStateData = WeakEmpty, THooks extends THooksBase = 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 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>;

package/build/classy/logic.js

@@ -1,27 +1,28 @@
 "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 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;
 }());
@@ -51,37 +52,30 @@ var useLogic = function () {
     return self;
 };
 exports.useLogic = useLogic;
-testing: {
-    var a = { b: '' };
-    var MyComponentLogic = /** @class */ (function (_super) {
-        __extends(MyComponentLogic, _super);
-        function MyComponentLogic() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        MyComponentLogic.getInitialState = function () { return ({ a: '' }); };
-        return MyComponentLogic;
-    }(ComponentLogic));
-    ;
-    MyComponentLogic.getInitialState;
+/*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);
-}
-testing: {
-    var A = /** @class */ (function (_super) {
-        __extends(C, _super);
-        function C() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        return C;
-    }(ComponentLogic));
+
+
+    const A = class C extends ComponentLogic {
+        // static getInitialState = () => ({a: 'l'});
+        // a = () => this.state.yyy = '';
+    }
+
     A.getInitialState();
+
     // const oa = {['a' as unknown as symbol]: 'boo'};
-    var oa = (_a = {}, _a['a'] = 'boo', _a);
+    const oa = {['a']: 'boo'};
     // const self = useLogic(A, oa);
-}
-// export type ComponentClassStatics<Instance extends ComponentLogic<object, object, object>> = {
-// 	getInitialState: (props?: Instance['props']) => TState<Instance['state']>;
-// }
-// export type TComponentClass<
-// 	Instance extends ComponentLogic<object, object, object>,
-// 	Params extends CnstPrm = CnstPrm
-// > = ComponentClassStatics<Instance> & Constructor<Instance, Params>;
+}*/

package/build/globals.js

@@ -2,13 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 /////////////
 var UniqueSecretSymbolKey = Symbol('asdfghjkliuytrewqaxcvb,nb');
-testing: {
-    var mySymbol = Symbol('asdfgh');
-    var tt = {
-    // [mySymbol]: '' as never,
-    // [UniqueSecretSymbolKey]: '',
-    // '': '',
-    };
-    var TT = {};
-    TT = tt;
-}

package/package.json

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