@cleanweb/oore 1.0.0

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

@@ -0,0 +1,144 @@
+import type { UseInstance } from './types/hook';
+import type { TPropsBase } from '../../classy/logic';
+import { ComponentLogic } from '../../classy/logic';
+type AsyncAllowedEffectCallback = () => Awaitable<IVoidFunction>;
+/**
+ * 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
+ */
+export declare class ComponentInstance<TProps extends TPropsBase = null> extends ComponentLogic<TProps> {
+    /**
+     * Runs only _before_ the first render,
+     * i.e before the component instance is mounted.
+     *
+     * It is ignored on subsequent rerenders.
+     * Uses `useMemo()` under the hood.
+     *
+     * 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 details}.
+     */
+    beforeMount: IVoidFunction;
+    /**
+     * Runs only **_after_** the 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
+     * logging and analytics.
+     *
+     * @returns A cleanup function.
+     *
+     * Uses `useEffect()` under the hood.
+     */
+    onMount: AsyncAllowedEffectCallback;
+    /**
+     * Stores the object returned by {@link beforeRender}.
+     * @see {@link templateContext}
+     */
+    private _templateContext;
+    /**
+     * Exposes the object returned by {@link beforeRender}.
+     *
+     * This is useful when you need to render some state or props
+     * in a transformed format. Put the transformation logic
+     * in {@link beforeRender} to the keep the main
+     * function component body clean.
+     *
+     * ******
+     *
+     * @example <caption>Using `templateContext`.</caption>
+     *
+     * ```tsx
+     * class MyComponentLogic extends ComponentInstance {
+     *     beforeRender = () => {
+     *         const title = `My Site | ${this.props.title}`;
+     *         return { title };
+     *     }
+     * }
+     * const MyComponent = (props) => {
+     *     const self = useInstance(MyComponentLogic, props);
+     *     const { templateContext: ctx, state } = self;
+     *
+     *     return (
+     *         <h1>
+     *             {ctx.title}
+     *         </h1>
+     *         <p>{props.description}</p>
+     *     );
+     * }
+     * ```
+     */
+    get templateContext(): ReturnType<this["beforeRender"]>;
+    /**
+     * Runs _before_ every render cycle, including the first.
+     * Useful for logic that is involved in determining what to render.
+     *
+     * It runs in the same way as logic placed directly into the
+     * function component body preceding the return statement.
+     *
+     * This is the ideal place to transform data for display.
+     * Return the transformed data in an object, and the object will
+     * availble as [`self.templateContext`]({@link templateContext})
+     * for use in your JSX template.
+     *
+     * 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 details}.
+     */
+    beforeRender: () => object | void;
+    /**
+     * Runs **_after_** every render cycle, including the first.
+     *
+     * Should usually only be used for logic that does not directly take part in determining what to render,
+     * like logging and analytics.
+     *
+     * Uses `useEffect()` under the hood.
+     *
+     * @returns A cleanup function.
+     */
+    onRender: AsyncAllowedEffectCallback;
+    /**
+     * Runs when the component is unmounted.
+     * It is called _after_ the cleanup function returned by onMount.
+     */
+    cleanUp: IVoidFunction;
+}
+/**
+ * Enables full separation of concerns between a React component's template
+ * and all of the logic that drives it.
+ *
+ * Returns an object that fully represents a logical instance
+ * of the rendered React component, with the exception of the JSX template itself.
+ *
+ * This means that all of your component's logic and lifecycle handlers
+ * can be externalized from the function component itself,
+ * and defined in a separate class.
+ *
+ * The provided class should be a subclass of {@link ComponentInstance}.
+ */
+export declare const useInstance: UseInstance;
+export {};
+/** /
+testing: {
+    class A extends ComponentInstance<EmptyObject> {
+        getInitialState = (p?: object) => ({putan: ''});
+        // k = this.props.o
+        am = this.state['_initialValues_'];
+        k = this.am.putan;
+
+        beforeRender = () => ({g: ''});
+
+        useHooks = () => {
+            return {j: 9};
+        };
+    }
+
+    const a = useInstance(A, {});
+    a.am;
+
+    // a.props['o'];
+    type bbbb = A['state'];
+    type ttt = bbbb['put'];
+}
+/**/

package/build/classy/instance/index.js

@@ -0,0 +1,202 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useInstance = exports.ComponentInstance = void 0;
+var react_1 = require("react");
+var logic_1 = require("../../classy/logic");
+var mount_callbacks_1 = require("./mount-callbacks");
+var helpers_1 = require("../../helpers");
+/**
+ * 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_ the first render,
+         * i.e before the component instance is mounted.
+         *
+         * It is ignored on subsequent rerenders.
+         * Uses `useMemo()` under the hood.
+         *
+         * 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 details}.
+         */
+        _this.beforeMount = function () { };
+        /**
+         * Runs only **_after_** the 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
+         * logging and analytics.
+         *
+         * @returns A cleanup function.
+         *
+         * Uses `useEffect()` under the hood.
+         */
+        _this.onMount = function () { return helpers_1.noOp; };
+        /**
+         * Runs _before_ every render cycle, including the first.
+         * Useful for logic that is involved in determining what to render.
+         *
+         * It runs in the same way as logic placed directly into the
+         * function component body preceding the return statement.
+         *
+         * This is the ideal place to transform data for display.
+         * Return the transformed data in an object, and the object will
+         * availble as [`self.templateContext`]({@link templateContext})
+         * for use in your JSX template.
+         *
+         * 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 details}.
+         */
+        _this.beforeRender = function () { };
+        /**
+         * Runs **_after_** every render cycle, including the first.
+         *
+         * Should usually only be used for logic that does not directly take part in determining what to render,
+         * like logging and analytics.
+         *
+         * Uses `useEffect()` under the hood.
+         *
+         * @returns A cleanup function.
+         */
+        _this.onRender = function () { return helpers_1.noOp; };
+        /**
+         * Runs when the component is unmounted.
+         * It is called _after_ the cleanup function returned by onMount.
+         */
+        _this.cleanUp = function () { };
+        return _this;
+    }
+    Object.defineProperty(ComponentInstance.prototype, "templateContext", {
+        /**
+         * Exposes the object returned by {@link beforeRender}.
+         *
+         * This is useful when you need to render some state or props
+         * in a transformed format. Put the transformation logic
+         * in {@link beforeRender} to the keep the main
+         * function component body clean.
+         *
+         * ******
+         *
+         * @example <caption>Using `templateContext`.</caption>
+         *
+         * ```tsx
+         * class MyComponentLogic extends ComponentInstance {
+         *     beforeRender = () => {
+         *         const title = `My Site | ${this.props.title}`;
+         *         return { title };
+         *     }
+         * }
+         * const MyComponent = (props) => {
+         *     const self = useInstance(MyComponentLogic, props);
+         *     const { templateContext: ctx, state } = self;
+         *
+         *     return (
+         *         <h1>
+         *             {ctx.title}
+         *         </h1>
+         *         <p>{props.description}</p>
+         *     );
+         * }
+         * ```
+         */
+        get: function () {
+            return this._templateContext;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ComponentInstance;
+}(logic_1.ComponentLogic));
+exports.ComponentInstance = ComponentInstance;
+;
+/**
+ * Enables full separation of concerns between a React component's template
+ * and all of the logic that drives it.
+ *
+ * Returns an object that fully represents a logical instance
+ * of the rendered React component, with the exception of the JSX template itself.
+ *
+ * This means that all of your component's logic and lifecycle handlers
+ * can be externalized from the function component itself,
+ * and defined in a separate class.
+ *
+ * The provided class should be a subclass of {@link ComponentInstance}.
+ */
+var useInstance = function () {
+    var _a;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var Component = args[0], _b = args[1], props = _b === void 0 ? {} : _b;
+    // useHooks.
+    var instance = (0, logic_1.useLogic)(Component, props);
+    // beforeMount, onMount, cleanUp.
+    (0, mount_callbacks_1.useMountCallbacks)(instance);
+    // beforeRender.
+    /**
+     * A proxy variable to allow typechecking of the assignment
+     * to `self.templateContext` despite the need for "readonly" error suppression.
+     */
+    var _templateContextProxy_;
+    // @ts-expect-error Assigning to a readonly property.
+    instance._templateContext = (_templateContextProxy_ = (_a = instance.beforeRender) === null || _a === void 0 ? void 0 : _a.call(instance));
+    // onRender.
+    (0, react_1.useEffect)(function () {
+        var _a;
+        var cleanupAfterRerender = (_a = instance.onRender) === null || _a === void 0 ? void 0 : _a.call(instance);
+        return function () {
+            if (typeof cleanupAfterRerender === 'function')
+                cleanupAfterRerender();
+            else
+                cleanupAfterRerender === null || cleanupAfterRerender === void 0 ? void 0 : cleanupAfterRerender.then(function (cleanUp) { return cleanUp === null || cleanUp === void 0 ? void 0 : cleanUp(); });
+        };
+    });
+    return instance;
+};
+exports.useInstance = useInstance;
+/** /
+testing: {
+    class A extends ComponentInstance<EmptyObject> {
+        getInitialState = (p?: object) => ({putan: ''});
+        // k = this.props.o
+        am = this.state['_initialValues_'];
+        k = this.am.putan;
+
+        beforeRender = () => ({g: ''});
+
+        useHooks = () => {
+            return {j: 9};
+        };
+    }
+
+    const a = useInstance(A, {});
+    a.am;
+
+    // a.props['o'];
+    type bbbb = A['state'];
+    type ttt = bbbb['put'];
+}
+/**/

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

@@ -0,0 +1,5 @@
+import { ComponentInstance } from '.';
+type UseMountCallbacks = <TInstance extends ComponentInstance>(instance: TInstance) => void;
+/** @internal */
+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");
+/** @internal */
+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();
+                (_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<NonNullable<any>>;
+type UIProplessClassParam = typeof ComponentInstance<null>;
+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<any>,
+    props?: object
+];
+export type UIReturn = ComponentInstance<any>;
+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,116 @@
+import type { TCleanState } from '../../base/state';
+import type { UseLogic } from './types/hook';
+/**
+ * The base type for the `props` type argument.
+ *
+ * This is not the type of the `props` property itself.
+ * It merely defines the type constraint for the type argument
+ * passed when extending any of the logic classes.
+ *
+ * It accepts null for components that don't take any props.
+ */
+export type TPropsBase = NonPrimitive | null;
+/**
+ * Base class for a class that holds methods to be used in a function component.
+ *
+ * These methods will always have access to the latest copy of
+ * the component's 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.
+ *
+ * @typeParam TProps - {@include ./types/tprops.md}
+ */
+export declare class ComponentLogic<TProps extends TPropsBase = null> {
+    /**
+     * A {@link TCleanState | `CleanState`} object.
+     * Holds all of your component's state,
+     * and methods for conveniently manipulating those values.
+     * Initialiazed with the object returned from your `getInitialState` method.
+     */
+    readonly state: TCleanState<ReturnType<this['getInitialState']>>;
+    /** The props passed into your component at the time of rendering. */
+    readonly props: TProps extends null ? EmptyObject : TProps;
+    /**
+     * Values received from the hooks your component consumes.
+     * This holds the latest copy of the object returned by
+     * {@link useHooks}.
+     *
+     * You should not mutate this object directly.
+     * `useHooks` is called on every render and the object it returns
+     * will completely overwrite whatever the previous value of `this.hooks` was.
+     * `this.hooks` should only be updated through the object returned from `useHooks`.
+     *
+     * If you need to update a value from outside `useHooks` as well, then consider
+     * wrapping it with {@link React.useRef}, since React refs are persisted across rerenders.
+     */
+    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 extends null ? undefined : 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;
+    /**
+     * Persist class members during HMR. {@include ./hrm-preserve-keys.md}
+     * @privateRemarks
+     * @see {@link https://cleanjsweb.github.io/neat-react/classes/API.BaseClasses.ComponentLogic.html#_hmrpreservekeys | Full details}
+     */
+    _hmrPreserveKeys: Array<keyof this | (string & {})>;
+    /**
+     * Run custom logic after HMR update. {@include ./on-hrm-update.md}
+     * @privateRemarks
+     * @see {@link https://cleanjsweb.github.io/neat-react/classes/API.BaseClasses.ComponentLogic.html#_onhmrupdate | Full details}
+     */
+    _onHmrUpdate?: <TInstance extends this>(oldInstance: TInstance) => void;
+}
+/**
+ * Returns an instance of the provided class, which holds methods for your component and
+ * encapsulates hook calls with the special {@link ComponentLogic.useHooks | `useHooks`} method.
+ *
+ * The class argument must be a subclass of {@link ComponentLogic}.
+ *
+ * @see https://cleanjsweb.github.io/neat-react/functions/API.useLogic.html
+ */
+export declare const useLogic: UseLogic;
+/** /
+testing: {
+    const a: object = {b: ''};
+
+    type t = keyof typeof a;
+
+    class MyComponentLogic extends ComponentLogic<{}> {
+        getInitialState = () => ({b: 7});
+        b = () => 8 + this.state.b;
+
+        useHooks = () => ({a: 'undefined'});
+    };
+
+    type tt = keyof {};
+
+    const self = useLogic(MyComponentLogic);
+    self.hooks;
+    self.useHooks();
+
+
+    const A = class C extends ComponentLogic {
+        getInitialState = () => ({a: 'l'});
+        a = () => this.state.a = '';
+    }
+
+    // const oa = {['a' as unknown as symbol]: 'boo'};
+    const oa = {['a']: 'boo'};
+    useLogic(A, oa);
+}
+/**/

package/build/classy/logic/index.js

@@ -0,0 +1,128 @@
+"use strict";
+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 to be used in a function component.
+ *
+ * These methods will always have access to the latest copy of
+ * the component's 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.
+ *
+ * @typeParam TProps - {@include ./types/tprops.md}
+ */
+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 () { };
+        /**
+         * Persist class members during HMR. {@include ./hrm-preserve-keys.md}
+         * @privateRemarks
+         * @see {@link https://cleanjsweb.github.io/neat-react/classes/API.BaseClasses.ComponentLogic.html#_hmrpreservekeys | Full details}
+         */
+        this._hmrPreserveKeys = [];
+    }
+    return ComponentLogic;
+}());
+exports.ComponentLogic = ComponentLogic;
+;
+/**
+ * Returns an instance of the provided class, which holds methods for your component and
+ * encapsulates hook calls with the special {@link ComponentLogic.useHooks | `useHooks`} method.
+ *
+ * The class argument must be a subclass of {@link ComponentLogic}.
+ *
+ * @see https://cleanjsweb.github.io/neat-react/functions/API.useLogic.html
+ */
+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;
+    // In production, we only use the latestInstance the first time, and it's ignored every other time.
+    // This means changing the class at runtime will have no effect in production.
+    // latestInstance is only extracted into a separate variable for use in dev mode during HMR.
+    var latestInstance = (0, react_1.useMemo)(function () { return new Logic(); }, [Logic]);
+    // const latestInstance = useMemo(() => new Logic(), []);
+    var instanceRef = (0, react_1.useRef)(latestInstance);
+    var refreshState = function () {
+        var _a;
+        // @ts-expect-error
+        instanceRef.current.props = props;
+        // @ts-expect-error
+        instanceRef.current.state = (0, state_1.useCleanState)(instanceRef.current.getInitialState, props);
+        // @ts-expect-error
+        instanceRef.current.hooks = (_a = instanceRef.current.useHooks()) !== null && _a !== void 0 ? _a : {};
+    };
+    if (process.env.NODE_ENV === 'development' && instanceRef.current !== latestInstance) {
+        var oldInstance_1 = instanceRef.current;
+        latestInstance._hmrPreserveKeys.forEach(function (_key) {
+            var key = _key;
+            // @ts-expect-error We're assigning to readonly properties. Also, Typescript doesn't know that the type of the left and right side will always match, due to the dynamic access.
+            latestInstance[key] = oldInstance_1[key];
+        });
+        Reflect.ownKeys(oldInstance_1).forEach(function (_key) {
+            var key = _key;
+            delete oldInstance_1[key];
+        });
+        Object.setPrototypeOf(oldInstance_1, latestInstance);
+        instanceRef.current = latestInstance;
+        refreshState();
+        (_a = latestInstance._onHmrUpdate) === null || _a === void 0 ? void 0 : _a.call(latestInstance, oldInstance_1);
+    }
+    else
+        refreshState();
+    return instanceRef.current;
+    ;
+};
+exports.useLogic = useLogic;
+/** /
+testing: {
+    const a: object = {b: ''};
+
+    type t = keyof typeof a;
+
+    class MyComponentLogic extends ComponentLogic<{}> {
+        getInitialState = () => ({b: 7});
+        b = () => 8 + this.state.b;
+
+        useHooks = () => ({a: 'undefined'});
+    };
+
+    type tt = keyof {};
+
+    const self = useLogic(MyComponentLogic);
+    self.hooks;
+    self.useHooks();
+
+
+    const A = class C extends ComponentLogic {
+        getInitialState = () => ({a: 'l'});
+        a = () => this.state.a = '';
+    }
+
+    // const oa = {['a' as unknown as symbol]: 'boo'};
+    const oa = {['a']: 'boo'};
+    useLogic(A, oa);
+}
+/**/

package/build/classy/logic/types/hook.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentLogic } from '..';
+/*************************************
+ *        # Hooks                    *
+**************************************/
+type ULClassParam = typeof ComponentLogic<NonNullable<any>>;
+type ULProplessClassParam = typeof ComponentLogic<null>;
+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<any>,
+    props?: object
+];
+export type ULReturn = ComponentLogic<any>;
+export {};

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

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

package/build/docs-src/api/base-classes.d.ts

@@ -0,0 +1,3 @@
+export { ComponentMethods } from '../../base/methods';
+export { ComponentLogic } from '../../classy/logic';
+export { ComponentInstance } from '../../classy/instance';

package/build/docs-src/api/base-classes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentInstance = exports.ComponentLogic = exports.ComponentMethods = void 0;
+var methods_1 = require("../../base/methods");
+Object.defineProperty(exports, "ComponentMethods", { enumerable: true, get: function () { return methods_1.ComponentMethods; } });
+var logic_1 = require("../../classy/logic");
+Object.defineProperty(exports, "ComponentLogic", { enumerable: true, get: function () { return logic_1.ComponentLogic; } });
+var instance_1 = require("../../classy/instance");
+Object.defineProperty(exports, "ComponentInstance", { enumerable: true, get: function () { return instance_1.ComponentInstance; } });