@cleanweb/oore 1.0.0

package/build/docs-src/api/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * API Reference
+ * @module API
+ */
+export { useCleanState } from '../../base/state';
+export { useMethods } from '../../base/methods';
+export { useLogic } from '../../classy/logic';
+export { useInstance } from '../../classy/instance';
+export { ClassComponent } from '../../classy/class';
+/** @namespace */
+export * as BaseClasses from './base-classes';
+export * as Helpers from '../../helpers';
+export * as References from './references';

package/build/docs-src/api/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * API Reference
+ * @module API
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.References = exports.Helpers = exports.BaseClasses = exports.ClassComponent = exports.useInstance = exports.useLogic = exports.useMethods = exports.useCleanState = void 0;
+var state_1 = require("../../base/state");
+Object.defineProperty(exports, "useCleanState", { enumerable: true, get: function () { return state_1.useCleanState; } });
+var methods_1 = require("../../base/methods");
+Object.defineProperty(exports, "useMethods", { enumerable: true, get: function () { return methods_1.useMethods; } });
+var logic_1 = require("../../classy/logic");
+Object.defineProperty(exports, "useLogic", { enumerable: true, get: function () { return logic_1.useLogic; } });
+var instance_1 = require("../../classy/instance");
+Object.defineProperty(exports, "useInstance", { enumerable: true, get: function () { return instance_1.useInstance; } });
+var class_1 = require("../../classy/class");
+Object.defineProperty(exports, "ClassComponent", { enumerable: true, get: function () { return class_1.ClassComponent; } });
+/** @namespace */
+exports.BaseClasses = __importStar(require("./base-classes"));
+exports.Helpers = __importStar(require("../../helpers"));
+exports.References = __importStar(require("./references"));

package/build/docs-src/api/references.d.ts

@@ -0,0 +1,5 @@
+export * as $CleanState from '../../base/state';
+export * as $ComponentMethods from '../../base/methods';
+export * as ComponentLogic from '../../classy/logic';
+export * as ComponentInstance from '../../classy/instance';
+export * as ClassComponent from '../../classy/class';

package/build/docs-src/api/references.js

@@ -0,0 +1,31 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassComponent = exports.ComponentInstance = exports.ComponentLogic = exports.$ComponentMethods = exports.$CleanState = void 0;
+exports.$CleanState = __importStar(require("../../base/state"));
+exports.$ComponentMethods = __importStar(require("../../base/methods"));
+exports.ComponentLogic = __importStar(require("../../classy/logic"));
+exports.ComponentInstance = __importStar(require("../../classy/instance"));
+exports.ClassComponent = __importStar(require("../../classy/class"));

package/build/globals.d.ts

@@ -0,0 +1,84 @@
+declare const UniqueSecretSymbolKey: unique symbol;
+/** /testing: {
+    const mySymbol = Symbol('asdfgh') as symbol;
+
+    const tt = {
+        // [mySymbol]: '' as never,
+        // [UniqueSecretSymbolKey]: '',
+        // '': '',
+    }
+
+    let TT: EmptyObject = {};
+    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>;
+    type Constructor<TInstance extends any = any, TParams extends any[] = never[]> = new (...args: TParams) => TInstance;
+    /**
+     * @example
+     * ```js
+     * const getNumber: AsyncFunction<number> = async () => {
+     * 	return 5;
+     * }
+     * ```
+     */
+    type AsyncFunction<TReturnValue extends any = void, Params extends any[] = never[]> = (...params: Params) => Promise<TReturnValue>;
+    /**
+     * A function that takes no arguments and returns nothing.
+     * 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 : 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 `EmptyObject`.
+     * ```
+     * This may provide a slightly stricter type checking than simply
+     * using the non-nullish (`{}`) or non-primitive (`object`)
+     * built-in types.
+     *
+     * Note: `EmptyObject` is not assignable to `NeverObject`
+     * because it has a key whose value type includes `undefined`,
+     * but `NeverObject` keys can only have a type of `never`.
+     */
+    interface EmptyObject {
+        [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 NeverObject {
+        [key: keyof any]: never;
+    }
+    type valueof<TObject> = TObject[keyof TObject];
+    interface Window {
+    }
+    namespace JSX {
+        interface IntrinsicElements {
+        }
+    }
+    namespace NodeJS {
+        interface ProcessEnv {
+            NODE_ENV: 'development' | 'production' | 'test';
+        }
+    }
+}
+export {};

package/build/globals.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/////////////
+var UniqueSecretSymbolKey = Symbol('asdfghjkliuytrewqaxcvb,nb');

package/build/helpers/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * <!-- @ mergeModuleWith API -->
+ * @module Helpers
+ */
+export * from './mount-state';
+export * from './rerender';
+export * from './use-component';
+export * from './type-guards';
+/**
+ * An empty function.
+ * It returns (void) without performing any operations.
+ */
+export declare const noOp: () => void;

package/build/helpers/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * <!-- @ mergeModuleWith API -->
+ * @module Helpers
+ */
+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 });
+exports.noOp = void 0;
+__exportStar(require("./mount-state"), exports);
+__exportStar(require("./rerender"), exports);
+__exportStar(require("./use-component"), exports);
+__exportStar(require("./type-guards"), exports);
+/**
+ * An empty function.
+ * It returns (void) without performing any operations.
+ */
+var noOp = function () { };
+exports.noOp = noOp;

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 created 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/helpers/rerender.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a function that can be called to manually trigger
+ * a rerender of your component.
+ */
+export declare const useRerender: () => () => void;

package/build/helpers/rerender.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRerender = void 0;
+var mount_state_1 = require("../helpers/mount-state");
+var react_1 = require("react");
+/**
+ * Returns a function that can be called to manually trigger
+ * a rerender of your component.
+ */
+var useRerender = function () {
+    var isMounted = (0, mount_state_1.useMountState)();
+    // 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 () {
+        if (isMounted()) {
+            _forceRerender(Date.now());
+            return;
+        }
+        setTimeout(function () {
+            if (isMounted())
+                _forceRerender(Date.now());
+            else {
+                console.log('Cannot rerender an unmounted component.');
+            }
+        }, 1000);
+    };
+    return rerender;
+};
+exports.useRerender = useRerender;

package/build/helpers/type-guards.d.ts

@@ -0,0 +1 @@
+export declare const canIndex: <T extends object>(key: keyof any, targetObject: T) => key is keyof T;

package/build/helpers/type-guards.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canIndex = void 0;
+var canIndex = function (key, targetObject) {
+    var test = typeof key === 'number' ? "".concat(key) : key;
+    return Reflect.ownKeys(targetObject).includes(test);
+};
+exports.canIndex = canIndex;

package/build/helpers/use-component/index.d.ts

@@ -0,0 +1,6 @@
+import type { ClassComponentHookWrapper } from './types';
+/**
+ * A component you can use to consume React hooks
+ * in a {@link Component | React.Component} class.
+ */
+export declare const Use: ClassComponentHookWrapper;

package/build/helpers/use-component/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Use = void 0;
+var react_1 = require("react");
+/**
+ * A component you can use to consume React hooks
+ * in a {@link Component | React.Component} class.
+ */
+var Use = function (params) {
+    var useGenericHook = params.hook, argumentsList = params.argumentsList, onUpdate = params.onUpdate;
+    var output = useGenericHook.apply(void 0, argumentsList);
+    (0, react_1.useEffect)(function () {
+        onUpdate(output);
+    }, [output]);
+    return null;
+};
+exports.Use = Use;

package/build/helpers/use-component/types.d.ts

@@ -0,0 +1,22 @@
+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;
+}
+export type ClassComponentHookWrapper = <Hook extends AnyFunction>(props: HookWrapperProps<Hook>) => null;
+export {};

package/build/helpers/use-component/types.js

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

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export * from './classy';
+export * from './base';
+export * from './helpers';
+export type { EmptyObject, NeverObject };

package/build/index.js

@@ -0,0 +1,19 @@
+"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("./classy"), exports);
+__exportStar(require("./base"), exports);
+__exportStar(require("./helpers"), exports);

package/build/tsconfig.json

@@ -0,0 +1,49 @@
+{
+	"compilerOptions": {
+		"baseUrl": ".",
+		"rootDir": ".",
+		"outDir": "build",
+		"paths": {
+			"@/*": [
+				"./*"
+			]
+		},
+		"target": "es5",
+		"lib": [
+			"dom",
+			"dom.iterable",
+			"esnext"
+		],
+		"allowJs": true,
+		"checkJs": true,
+		"declaration": true,
+		"noEmit": false,
+		"skipLibCheck": true,
+		"strict": false,
+		"forceConsistentCasingInFileNames": true,
+		"incremental": false,
+		"esModuleInterop": true,
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"resolveJsonModule": true,
+		"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/**/**.*"
+	]
+}

package/package.json

@@ -0,0 +1,87 @@
+{
+	"name": "@cleanweb/oore",
+	"version": "1.0.0",
+	"description": "A library of helpers for writing cleaner React function components.",
+	"engines": {
+		"node": ">=18"
+	},
+	"files": [
+		"build",
+		".npmrc"
+	],
+	"main": "build/index.js",
+	"//exports/.": {
+		"require": "./src/index.cjs",
+		"import": "./src/index.mjs"
+	},
+	"//type": "module",
+	"exports": {
+		".": "./build/classy/index.js",
+		"./base": "./build/base/index.js",
+		"./helpers": "./build/helpers/index.js",
+		"./all": "./build/index.js"
+	},
+	"scripts": {
+		"prebuild": "rimraf ./build && npm run build:docs",
+		"build": "tsc && tsc-alias",
+		"serve-docs": "serve docs",
+		"postbuild": "copyfiles tsconfig.json build",
+		"build:docs": "typedoc",
+		"_": "",
+		"prepublishOnly": "npm run build",
+		"publish:patch": "npm version patch && npm publish",
+		"publish:minor": "npm version minor && npm publish",
+		"publish:major": "npm version major && npm publish",
+		"__": "/// Increment beta number for the current patch version. ///",
+		"publish:beta:current": "npm version prerelease --preid beta && npm publish --tag beta",
+		"___": "/// Create a beta.0 for a new patch/minor/major version ///",
+		"publish:beta:new-patch": "npm version prepatch --preid beta && npm publish --tag beta",
+		"publish:beta:new-minor": "npm version preminor --preid beta && npm publish --tag beta",
+		"publish:beta:new-major": "npm version premajor --preid beta && npm publish --tag beta",
+		"____": "",
+		"//postpublish": "cd ./mirror-pkg && npm publish && cd ..",
+		"______": "",
+		"test": "echo \"No tests ATM\""
+	},
+	"keywords": [
+		"react",
+		"function components",
+		"class components",
+		"hooks",
+		"react hooks",
+		"react state",
+		"state",
+		"clean state",
+		"group state",
+		"grouped state"
+	],
+	"author": {
+		"name": "Feranmi Akinlade",
+		"url": "https://feranmi.dev"
+	},
+	"license": "MIT",
+	"devDependencies": {
+		"@babel/eslint-parser": "^7.25.9",
+		"@babel/preset-typescript": "^7.26.0",
+		"@types/node": "20.14.10",
+		"@types/react": "^16",
+		"@types/webpack-env": "^1.18.8",
+		"babel-preset-react-app": "^10.0.1",
+		"copyfiles": "^2.4.1",
+		"eslint": "^9.15.0",
+		"eslint-plugin-jsdoc": "^50.5.0",
+		"eslint-plugin-react": "^7.37.2",
+		"globals": "^15.12.0",
+		"rimraf": "^6.0.1",
+		"serve": "^14.2.4",
+		"tsc-alias": "1.8.10",
+		"typedoc": "latest",
+		"typedoc-plugin-coverage": "^3.4.1",
+		"typedoc-plugin-markdown": "^4.4.1",
+		"typedoc-plugin-mdn-links": "^4.0.13",
+		"typescript": "^5.6.2"
+	},
+	"peerDependencies": {
+		"react": ">=16"
+	}
+}