@cleanweb/react 1.1.1-beta.9 → 2.1.0-beta.0

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

@@ -15,68 +15,52 @@ 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`.
+ *
+ * @see https://github.com/cleanjsweb/neat-react#lifecycle-useinstance
+ */
 var ComponentInstance = /** @class */ (function (_super) {
     __extends(ComponentInstance, _super);
     function ComponentInstance() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
         /**
-         * Runs only _before_ first render, i.e before the component instance is mounted.
-         * Useful for logic that is involved in determining what to render.
+         * Runs only _before_ first render,
+         * i.e before the component instance is mounted.
          *
-         * Updating local state from in here will abort the render cycle early, before changes are committed to the DOM,
-         * and prompt React to immediately rerender the component with the updated state value(s).
+         * It is ignored on subsequent rerenders.
          *
-         * Ignored on subsequent rerenders.
+         * PS: You can conditionally update state from here, but with certain caveats.
+         * {@link https://react.dev/reference/react/useState#storing-information-from-previous-renders | See the React docs for more details}.
          */
         _this.beforeMount = function () { };
         /**
          * Runs only **_after_** first render, i.e after the component instance is mounted.
+         * It is ignored on subsequent rerenders.
          *
          * Should usually only be used for logic that does not directly take part in determining what to render, like
          * synchronize your component with some external system.
          *
-         * Ignored on subsequent rerenders.
+         * @returns A cleanup function.
          *
-         * Returns a cleanup function.
+         * Uses `useEffect()` under the hood.
          */
         _this.onMount = function () { return exports.noOp; };
         /**
          * Runs _before_ every render cycle, including the first.
          * Useful for logic that is involved in determining what to render.
          *
-         * Updating local state from in here will abort the render cycle early, before changes are committed to the DOM,
-         * and prompt React to immediately rerender the component with the updated state value(s).
+         * PS: You can conditionally update state from here, but with certain caveats.
+         * {@link https://react.dev/reference/react/useState#storing-information-from-previous-renders | See the React docs for more details}.
          */
         _this.beforeRender = function () { };
         /**
@@ -85,6 +69,8 @@ var ComponentInstance = /** @class */ (function (_super) {
          * Should usually only be used for logic that does not directly take part in determining what to render, like
          * synchronize your component with some external system.
          *
+         * Uses `useEffect()` under the hood.
+         *
          * Returns a cleanup function.
          */
         _this.onRender = function () { return exports.noOp; };
@@ -95,11 +81,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));
 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 +109,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 +125,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,12 +148,25 @@ var useInstance = function () {
     return instance;
 };
 exports.useInstance = useInstance;
+/**/
 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;
+            _this.getInitialState = function (p) { return ({ putan: '' }); };
+            // k = this.props.o
+            _this.am = _this.state['_initialValues_'];
+            _this.k = _this.am.putan;
+            _this.beforeRender = function () { return ({ g: '' }); };
+            _this.useHooks = function () {
+                return { j: 9 };
+            };
+            return _this;
         }
         return A;
     }(ComponentInstance));
+    var a = (0, exports.useInstance)(A, {});
+    a.am;
 }
+/**/

package/build/classy/instance/mount-callbacks.d.ts

@@ -0,0 +1,4 @@
+import { ComponentInstance } from '.';
+type UseMountCallbacks = <TInstance extends ComponentInstance>(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 mount_state_1 = require("../../helpers/mount-state");
+var useMountCallbacks = function (instance) {
+    var _a;
+    var isMounted = (0, mount_state_1.useMountState)();
+    if (!isMounted())
+        (_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,13 @@
+import { ComponentInstance } from '..';
+type UIClassParam = typeof ComponentInstance<object>;
+type UIProplessClassParam = typeof ComponentInstance<HardEmptyObject>;
+export type UseInstance = {
+    <Class extends UIProplessClassParam>(Methods: Class): InstanceType<Class>;
+    <Class extends UIClassParam>(Methods: Class, props: InstanceType<Class>['props']): InstanceType<Class>;
+};
+export type UIParams = [
+    Class: typeof ComponentInstance,
+    props?: object
+];
+export type UIReturn = ComponentInstance;
+export {};

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

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

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

@@ -0,0 +1,48 @@
+import type { TCleanState } from '../../base/state';
+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 = {}> {
+    /**
+     * A {@link TCleanState | `CleanState`} object.
+     * Holds all of your component's state,
+     * and methods for conveniently manipulating those values.
+     */
+    readonly state: TCleanState<ReturnType<this['getInitialState']>>;
+    /** The props pass into your component at the time of rendering. */
+    readonly props: TProps;
+    /**
+     * Values received from the hooks your component consumes.
+     * This holds the latest copy of the object returned by
+     * {@link useHooks}.
+     */
+    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.
+     */
+    getInitialState: (props?: TProps) => object;
+    /**
+     * Call React hooks from here. If your component needs
+     * access to values return from the hooks you call,
+     * expose those values by returning an object with said values.
+     *
+     * The returned object will be accessible as {@link hooks | `this.hooks`} within
+     * your component class.
+     */
+    useHooks: () => object | void;
+}
+export declare const useLogic: UseLogic;

package/build/classy/logic/index.js

@@ -0,0 +1,113 @@
+"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() {
+        /**
+         * 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.
+         */
+        this.getInitialState = function (props) { return ({}); };
+        /**
+         * Call React hooks from here. If your component needs
+         * access to values return from the hooks you call,
+         * expose those values by returning an object with said values.
+         *
+         * The returned object will be accessible as {@link hooks | `this.hooks`} within
+         * your component class.
+         */
+        this.useHooks = function () { };
+    }
+    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 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_ = (0, state_1.useCleanState)(self.getInitialState, props));
+    // @ts-expect-error
+    self.hooks = (_hooksProxy_ = (_a = self.useHooks()) !== null && _a !== void 0 ? _a : {});
+    return self;
+};
+exports.useLogic = useLogic;
+/**/
+testing: {
+    var a = { b: '' };
+    var MyComponentLogic = /** @class */ (function (_super) {
+        __extends(MyComponentLogic, _super);
+        function MyComponentLogic() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.getInitialState = function () { return ({ b: 7 }); };
+            _this.b = function () { return 8 + _this.state.b; };
+            _this.useHooks = function () { return ({ a: 'undefined' }); };
+            return _this;
+        }
+        return MyComponentLogic;
+    }(ComponentLogic));
+    ;
+    var self_1 = (0, exports.useLogic)(MyComponentLogic);
+    self_1.hooks;
+    self_1.useHooks();
+    var A = /** @class */ (function (_super) {
+        __extends(C, _super);
+        function C() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.getInitialState = function () { return ({ a: 'l' }); };
+            _this.a = function () { return _this.state.a = ''; };
+            return _this;
+        }
+        return C;
+    }(ComponentLogic));
+    // 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,17 @@
+import type { ComponentLogic } from '..';
+/*************************************
+ *        # Hooks                    *
+**************************************/
+/** */
+type ULClassParam = typeof ComponentLogic<object>;
+type ULProplessClassParam = typeof ComponentLogic<HardEmptyObject>;
+export type UseLogic = {
+    <Class extends ULProplessClassParam>(Methods: Class): InstanceType<Class>;
+    <Class extends ULClassParam>(Methods: Class, props: InstanceType<Class>['props']): InstanceType<Class>;
+};
+export type ULParams = [
+    Class: typeof ComponentLogic,
+    props?: object
+];
+export type ULReturn = ComponentLogic;
+export {};

package/build/classy/logic/types/hook.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,46 @@ 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;
+    /** @deprecated Use {@link NonNullish} */
+    type NotNullish = {};
+    type NonNullish = {};
+    type NonPrimitive = object;
+    /**
+     * Describes an object that has no keys,
+     * except for a secret unique symbol key,
+     * whose value type is the union `never | undefuned`.
+     *
+     * Having a single key allows the object to throw type errors
+     * of the form:
+     * ```
+     * Type `A` has no properties in common with `WeakEmptyObject`.
+     * ```
+     * This may provide a slightly stricter type checking than simply
+     * using the non-nullish (`{}`) or non-primitive (`object`)
+     * built-in types.
+     *
+     * Note: `WeakEmptyObject` is not assignable to `HardEmptyObject`
+     * because it has a key whose value type includes `undefined`,
+     * but `HardEmptyObject` keys can only have a type of `never`.
+     */
+    interface WeakEmptyObject {
+        [UniqueSecretSymbolKey]?: never;
+    }
+    /**
+     * Describes an object that can have any key, but all keys have
+     * a type of `never`. This effectively prevents any value
+     * from ever being stored on the object. The object is therefore
+     * guaranteed to always be empty.
+     */
+    interface HardEmptyObject {
+        [key: keyof any]: never;
+    }
+    type valueof<TObject> = TObject[keyof TObject];
     interface Window {
     }
     namespace JSX {
@@ -52,16 +79,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/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './mount-state';

package/build/helpers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mount-state"), exports);

package/build/helpers/mount-state.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a value that is false before the component has been mounted,
+ * then true during all subsequent rerenders.
+ */
+export declare const useMountState: () => () => boolean;

package/build/helpers/mount-state.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMountState = void 0;
+var react_1 = require("react");
+/**
+ * Returns a value that is false before the component has been mounted,
+ * then true during all subsequent rerenders.
+ */
+var useMountState = function () {
+    /**
+     * This must not be a state value. It should not be the cause of a rerender.
+     * It merely provides information about the render count,
+     * without influencing that count itself.
+     * So `mounted` should never be set with `useState`.
+     */
+    var mounted = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(function () {
+        mounted.current = true;
+        return function () {
+            mounted.current = false;
+        };
+    }, []);
+    return function () { return mounted.current; };
+};
+exports.useMountState = useMountState;

package/build/index.d.ts

@@ -1 +1,3 @@
-export * from "./classy";
+export * from './classy';
+export * from './base';
+export * from './helpers';

package/build/index.js

@@ -15,24 +15,12 @@ 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.
-// useCleanState => useState, separate call for each key
-// useMergedState => useState, same call for all keys
-// useMethods => useCallback
-// useLogic => useCallback + all other hook calls.
-// useInstance => useLogic + lifecycle methods.
-/*
-- Write usage doc
-- Push to git and publish to site
-    - Follow-up personal post on class component inheritance can be published on GH Pages from profile repo.
-- Publish to NPM
-- Finalize package and repo names, then post to Twitter.
-*/
+__exportStar(require("./base"), exports);
+__exportStar(require("./helpers"), exports);
 /*
 withFetchApi(baseUrl); To mimic axios.get and axios.post type calls.
 @cleanweb/mem-store - Release global-store package here.
-Use mem-store to cache requests in createApi(); Use md5 hashed url as key.
+Use mem-store to cache requests in withFetchApi(); Use md5 hashed url+body as key.
 @todo Add simple persistence layer with indexed db.
 @cleanweb/subscribable - To publish changes in the data to subscribers.
 @cleanweb/reactive-data - To combine all 4.

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/**/**.*"