@expressive/mvc 1.0.0-beta.9 → 1.0.0

package/package.json

@@ -1,6 +1,5 @@
 {
   "name": "@expressive/mvc",
-  "version": "1.0.0-beta.9",
   "description": "Use classes to define state in React!",
   "author": {
     "name": "Gabe Klein",
@@ -14,42 +13,41 @@
   },
   "keywords": [
     "react",
-    "hooks"
+    "mvc"
   ],
   "main": "lib/index.js",
-  "types": "types/index.d.ts",
+  "module": "lib/index.esm.js",
+  "types": "lib/index.d.ts",
   "files": [
-    "lib",
-    "types"
+    "lib"
   ],
   "scripts": {
     "build": "rollup --config",
-    "watch": "rollup --config --sourcemap --watch",
+    "watch": "jest --watchAll",
+    "test": "jest --collectCoverage",
     "prebuild": "rm -rf lib/",
-    "publish:pre": "npm version prerelease --preid=beta",
-    "preversion": "jest",
-    "postversion": "npm run build; npm publish",
-    "postpublish": "git push; git push --tags; rm -rf lib",
-    "coverage": "jest --collectCoverage",
-    "test": "jest --watchAll"
+    "preversion": "npm run test && npm run build",
+    "postversion": "git push & npm publish"
   },
   "peerDependencies": {
-    "react": ">=17.0.2"
+    "react": ">=16.8.0 <19.0.0"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^19.0.0",
-    "@rollup/plugin-typescript": "^8.2.1",
-    "@testing-library/react-hooks": "^7.0.0",
-    "@types/jest": "^26.0.23",
+    "@rollup/plugin-commonjs": "^22.0.0",
+    "@testing-library/react-hooks": "^8.0.0",
+    "@types/jest": "^27.4.1",
     "@types/node": "^15.12.4",
     "@types/react": "^17.0.11",
-    "jest": "^27.0.4",
+    "@types/react-test-renderer": "^18.0.0",
+    "jest": "^27.5.1",
     "react": ">=17.0.2",
     "react-test-renderer": "^17.0.2",
-    "rollup": "^2.52.2",
-    "rollup-plugin-typescript2": "^0.30.0",
+    "rollup": "^2.61.1",
+    "rollup-plugin-dts": "^4.2.1",
+    "rollup-plugin-typescript2": "^0.31.1",
     "ts-jest": "^27.0.3",
     "tslib": "^2.3.0",
-    "typescript": "typescript@>=3.8 <5.0"
-  }
+    "typescript": "4.6.3"
+  },
+  "version": "1.0.0"
 }

package/types/context.d.ts

@@ -1,59 +0,0 @@
-import { Consumer, ReactElement, ReactNode, Component, ComponentType } from "react";
-import { Model } from "./model"
-import { Class } from "./types";
-
-type Output = ReactElement<any, any> | null;
-
-export namespace Provider {
-    type Item = Model | typeof Model;
-    type Collection<T extends Item> = T[] | { [key: string]: T };
-    type Existent<E> = E extends Class ? InstanceType<E> : E extends Model ? E : never;
-    
-    type NormalProps<E, I = Existent<E>> =
-        & { of: E, children: ReactNode | ((instance: I) => ReactNode) }
-        & Model.Data<I>;
-
-    // FIX: This fails to exclude properties with same key but different type.
-    type MultipleProps<T extends Item> =
-        & { of: Collection<T>, children?: ReactNode | (() => ReactNode) }
-        & Model.Data<Existent<T>>;
-
-    type Props<T extends Item> = MultipleProps<T> | NormalProps<T>;
-}
-
-export function Provider<T extends Provider.Item>(props: Provider.Props<T>): Output;
-
-export namespace Consumer {
-    type HasProps<E extends Class> = {
-        /** Type of controller to fetch from context. */
-        of: E;
-        /**
-         * Getter function. Is called on every natural render of this component.
-         * Will throw if usable instance cannot be found in context.
-         */
-        has: (value: InstanceType<E>) => void;
-    }
-    
-    type GetProps<E extends Class> = {
-        /** Type of controller to fetch from context. */
-        of: E;
-        /** Getter function. Is called on every natural render of this component. */
-        get: (value: InstanceType<E> | undefined) => void;
-    }
-    
-    type RenderProps<E extends Class> = {
-        /** Type of controller to fetch from context. */
-        of: E;
-        /**
-         * Render function, will receive instance of desired controller.
-         *
-         * Similar to `tap()`, updates to properties accessed in
-         * this function will cause a refresh when they change.
-         */
-        children: (value: InstanceType<E>) => Output;
-    }
-
-    type Props<T extends Class> = HasProps<T> | GetProps<T> | RenderProps<T>
-}
-
-export function Consumer<T extends Class>(props: Consumer.Props<T>): Output;

package/types/dispatch.d.ts

@@ -1,55 +0,0 @@
-import { Model } from './model';
-import { Selector } from './selector';
-import { Callback, EffectCallback, UpdateCallback } from './types';
-
-type CallbackFor<S extends Selector.Function<any>, T> =
-  (this: T, value: Selector.Gets<S>, key: Selector.From<S>) => void;
-
-/**
- * Observable Instance
- * 
- * Implements internal value tracking. 
- * Able to be subscribed to, per-value to know when updated.
- */
-interface Dispatch {
-  // Keyed
-  on <S extends Model.SelectEvents<this>> (via: S, cb: CallbackFor<S, this>, squash?: false, once?: boolean): Callback;
-  on <P extends Model.EventsCompat<this>> (key: P | P[], listener: UpdateCallback<this, P>, squash?: false, once?: boolean): Callback;
-  // Squash
-  on <S extends Model.SelectEvents<this>> (via: S, cb: (keys: Selector.From<S>[]) => void, squash: true, once?: boolean): Callback;
-  on <P extends Model.EventsCompat<this>> (key: P | P[], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
-  // Unknown
-  on <S extends Model.SelectEvents<this>> (via: S, cb: unknown, squash: boolean, once?: boolean): Callback;
-  on <P extends Model.EventsCompat<this>> (key: P | P[], listener: unknown, squash: boolean, once?: boolean): Callback;
-
-  // Keyed
-  once <S extends Model.SelectEvents<this>> (via: S, cb: CallbackFor<S, this>, squash?: false): Callback;
-  once <P extends Model.EventsCompat<this>> (key: P | P[], listener: UpdateCallback<this, P>, squash?: false): Callback;
-  // Squash
-  once <S extends Model.SelectEvents<this>> (via: S, cb: (keys: Selector.From<S>[]) => void, squash: true): Callback;
-  once <P extends Model.EventsCompat<this>> (key: P | P[], listener: (keys: P[]) => void, squash: true): Callback;
-  // Promise
-  once <S extends Model.SelectEvents<this>> (via: S): Promise<Selector.From<S>[]>;
-  once <P extends Model.EventsCompat<this>> (key: P | P[]): Promise<P[]>;
-  // Unknown
-  once <S extends Model.SelectEvents<this>> (via: S, cb: unknown, squash: boolean): Callback;
-  once <P extends Model.EventsCompat<this>> (key: P | P[], listener: unknown, squash: boolean): Callback;
-
-  effect(callback: EffectCallback<this>, select?: Model.SelectFields<this>): Callback;
-  effect(callback: EffectCallback<this>, select?: (keyof this)[]): Callback;
-
-  import <O extends Model.Data<this>> (via: O, select?: string[] | Model.SelectFields<this>): void;
-
-  export(): Model.State<this>;
-  export <P extends Model.Fields<this>> (select: P[]): Model.State<this, P>;
-  export <S extends Model.SelectFields<this>> (select: S): Model.State<this, Selector.From<S>>;
-
-  update(strict: true): Promise<string[]>;
-  update(strict: false): Promise<false>;
-  update(strict?: boolean): Promise<string[] | false>;
-  update(keys: Model.Fields<this>[]): Promise<string[]>;
-  update(keys: Model.Fields<this>): Promise<string[]>;
-  update(keys: Model.SelectFields<this>): Promise<string[]>;
-}
-
-export = Dispatch;

package/types/index.d.ts

@@ -1,9 +0,0 @@
-export {
-    Model,
-    Model as default,
-    Singleton
-} from './model';
-
-export * from './context';
-export * from './instructions';
-export * from './selector';

package/types/instructions.d.ts

@@ -1,101 +0,0 @@
-import Model from '.';
-import { Async, Class, EffectCallback, InstanceOf } from './types';
-
-/**
- * Run instruction as controller sets itself up.
- * This will specialize the behavior of a given property.
- **/
-export function set <T = any> (
-  instruction: Model.Instruction<T>,
-  name?: string
-): T;
-
-/**
- * Creates a new child-instance of specified controller.
- * 
- * @param Peer - Type of Model to create and apply to host property.
- * @param callback - Fired after controller is created and ready for use.
- */
- export function use <T extends typeof Model> (Peer: T, callback: (i?: InstanceOf<T>) => void): InstanceOf<T> | undefined;
- export function use <T extends typeof Model> (Peer: T, required: false): InstanceOf<T> | undefined;
- export function use <T extends typeof Model> (Peer: T, required?: true): InstanceOf<T>;
- export function use <T extends Model | undefined> (Peer: () => T, callback?: (i: T) => void): T;
- export function use <T extends Model> (): T | undefined;
-
- /**
-  * Fetches and assigns the controller which spawned this host.
-  * When parent assigns an instance via `use()` directive, it
-  * will be made available to child upon this request.
-  * 
-  * @param Expects - Type of controller compatible with this class. 
-  * @param required - Throw if controller is created independantly.
-  */
- export function parent <T extends typeof Model> (Expects: T, required: true): InstanceOf<T>;
- export function parent <T extends typeof Model> (Expects: T, required?: false): InstanceOf<T> | undefined;
- 
- /**
-  * Find and attach most applicable instance of Model via context.
-  * 
-  * Expects a `<Provider>` of target controller to exist. 
-  * Host controller will search element-hierarchy relative to where it spawned.
-  * 
-  * @param Type - Type of controller to attach to property. 
-  * @param required - Throw if instance of Type cannot be found.
-  */
- export function tap <T extends Class> (Type: T, required?: boolean): InstanceOf<T>;
- 
- /**
-  * Sets property to synchronously call effect upon update.
-  * 
-  * @param starting - Beginning value of host property.
-  * @param callback - Effect-callback fired upon set of host property.
-  */
- export function on <T = any> (initial: undefined, callback: EffectCallback<T>): T | undefined;
- export function on <T = any> (initial: T, callback: EffectCallback<T>): T;
-
- /**
-  * Creates a ref-compatible property for use with components.
-  * Will persist value, and updates to this are made part of controller event-stream.
-  * 
-  * *Output is simultaneously a ref-function and ref-object, use as needed.*
-  * 
-  * @param callback - Optional callback to synchronously fire when reference is first set or does update.
-  */
- export function ref <T = HTMLElement> (callback?: EffectCallback<T>): Model.Ref<T>;
-
- /**
-  * Sets an exotic method with managed ready-state. Property accepts an async function.
-  * 
-  * When an act-method is invoked, its `active` property to true for duration of call.
-  * This is emitted as an update to property, both when called and after returns (or throws).
-  * 
-  * **Note:** Subsequent calls will immediately throw if one is still pending.
-  * 
-  * @param action - Action to fire when resulting property is invoked.
-  */
- export function act <T extends Async>(action: T): T & { active: boolean };
- 
- /**
-  * Implement a computed value; output will be generated by provided function.
-  * 
-  * *Alternative to using native getters; works exactly the same!*
-  * 
-  * @param fn - Factory function to generate value and subscribe dependancies.
-  */
- export function from <T, R>(fn: (this: T, on: T) => R): R;
-
- /**
-  * Memoized value. Computes and stores a value returned by provided factory. 
-  * Equivalent to a getter, sans the automatic updates.
-  * 
-  * @param compute - Factory for memoized value.
-  * @param lazy - Wait until accessed to introduce value.
-  */
- export function memo <T> (compute: () => T, lazy?: boolean): T;
- 
- /**
-  * Flag property as not to be tracked. Useful if changes often with no real-time impact.
-  * 
-  * @param value - starting value of property.
-  */
- export function lazy <T> (value?: T): T;

package/types/lifecycle.d.ts

@@ -1,30 +0,0 @@
-import { Key } from "./types";
-
-/**
- * Model-Component Lifecycle
- * 
- * Target contains available lifecycle callbacks. 
- * A controller, when subscribed to within a component, will
- * call these respectively to that component's lifecycle.
- */
-interface Lifecycle {
-  didMount?(tag?: Key): void;
-  willRender?(tag?: Key): void;
-  willUpdate?(tag?: Key): void;
-  willMount?(tag?: Key): void;
-  willUnmount?(tag?: Key): void;
-
-  elementDidMount?(tag: Key): void;
-  elementWillRender?(tag: Key): void;
-  elementWillUpdate?(tag: Key): void;
-  elementWillMount?(tag: Key): void;
-  elementWillUnmount?(tag: Key): void;
-
-  componentDidMount?(): void;
-  componentWillRender?(): void;
-  componentWillUpdate?(): void;
-  componentWillMount?(): void;
-  componentWillUnmount?(): void;
-}
-
-export = Lifecycle;