@cyysummer/projector 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,6 +1,7 @@
 /**
-* @cyysummer/projector v0.0.2
+* @cyysummer/projector v0.0.4
 * (c) 2021-PRESENT Chris Liu
 * @license MIT
 **/
-import _ from"on-change";import{set as g}from"lodash-es";import{withEvents as S}from"@cyysummer/core";var T=class extends S(){constructor(e){super();this._paused=!1;this._shadow=structuredClone(e)}record(e,r){this._paused||(g(this._shadow,e,r),this.emit("record",{next:this._shadow,path:e,value:r}))}pause(){this._paused=!0}resume(){this._paused=!1}};import{get as p}from"lodash-es";var l=a=>{},h=class{constructor(t){this._strategy=t}chain(t){return async(e,r)=>{let c=s(r);for(let o of t)await o(e,{value:c})}}chainWith(t,e){return async(c,o)=>{let u=s(o),n=e(u);for(let f of t)await f(c,{value:n})}}create(t){return(e,r)=>{let c=s(r);return this._strategy.execute(e,t,c)}}createIf(t,e,r=l){return(c,o)=>{let u=s(o);return(t(u)?e:r)(c,{value:u})}}createIfRoot(t,e,r=l){return(c,o)=>(t(o.source)?e:r)(c,o)}createRoot(t,e){return(r,c)=>{let o=e(c.source);return this._strategy.execute(r,t,o)}}createForArray(t){return(e,r)=>{let c=r.path?p(r.source,r.path):r.value;if(c&&Array.isArray(c)&&c.length>0){let o=Object.keys(c[0]);return this._strategy.executeArray(e,t,o,c)}}}createForRaw(t,e){return(r,c)=>this._strategy.execute(r,t,e)}createWith(t,e){return(c,o)=>{let u=s(o),n=e(u);return this._strategy.execute(c,t,n)}}};function s(a){return a.source&&a.path?p(a.source,a.path):a.value}var y=class{constructor(t,e){this._schema=t;this._scheduler=e}project(t,...e){if(!this._schema)throw new Error("Schema not loaded");for(let r of e)this._dispatch(t,r)}_dispatch(t,e){let{path:r,value:c}=e,o=this._resolveEffect(r);o&&this._scheduler.enqueue({path:r.join("."),effect:o,ctx:{source:t,path:r,value:c}})}_resolveEffect(t){let e=this._schema;for(let r of t){if(!e)return null;e=e[r]}return typeof e=="function"?e:null}};var i=class{constructor(t=null){this._target=t;this._targetFactory=null}withTarget(t){return typeof t=="function"?this._targetFactory=t:this._target=t,this}checkTarget(){if(!this._target&&this._targetFactory&&(this._target=this._targetFactory()),!this._target)throw new Error("Scheduler: target is not set")}},d=class extends i{constructor(){super(...arguments);this._queue=new Map}enqueue(e){return this._queue.set(e.path,e),this}async flush(){this.checkTarget(),log.trace("BufferedScheduler: flushing");let e=[...this._queue.values()];this._queue.clear();for(let r of e){let{effect:c,ctx:o}=r,u=c(this._target,o);u instanceof Promise&&await u}}};function F(a){let t=new T(a);return[_(a,t.record.bind(t),{pathAsArray:!0}),t]}export{d as BufferedScheduler,h as EffectBuilder,y as Projector,T as Recorder,i as Scheduler,F as track};
+import _ from"on-change";import{set as d}from"lodash-es";import{withEvents as g}from"@cyysummer/core";var i=class extends g(){constructor(e){super();this._paused=!1;this._shadow=structuredClone(e)}receive(e,r){if(this._paused)return;d(this._shadow,e,r);let c=[{path:e,value:r}];this.emit("record",{next:this._shadow,patches:c}),this._checkProjector(),this._projector?.project(this._shadow,...c)}sendTo(e){typeof e=="function"?this._projectorFactory=e:this._projector=e}pause(){this._paused=!0}resume(){this._paused=!1}_checkProjector(){!this._projector&&this._projectorFactory&&(this._projector=this._projectorFactory())}};import{get as l}from"lodash-es";var h=a=>{},p=class{constructor(t){this._strategy=t}chain(t){return async(e,r)=>{let c=n(r);for(let o of t)await o(e,{value:c})}}chainWith(t,e){return async(c,o)=>{let u=n(o),s=e(u);for(let f of t)await f(c,{value:s})}}create(t){return(e,r)=>{let c=n(r);return this._strategy.execute(e,t,c)}}createIf(t,e,r=h){return(c,o)=>{let u=n(o);return(t(u)?e:r)(c,{value:u})}}createIfRoot(t,e,r=h){return(c,o)=>(t(o.source)?e:r)(c,o)}createRoot(t,e){return(r,c)=>{let o=e(c.source);return this._strategy.execute(r,t,o)}}createForArray(t){return(e,r)=>{let c=r.path?l(r.source,r.path):r.value;if(c&&Array.isArray(c)&&c.length>0){let o=Object.keys(c[0]);return this._strategy.executeArray(e,t,o,c)}}}createForRaw(t,e){return(r,c)=>this._strategy.execute(r,t,e)}createWith(t,e){return(c,o)=>{let u=n(o),s=e(u);return this._strategy.execute(c,t,s)}}};function n(a){return a.source&&a.path?l(a.source,a.path):a.value}var y=class{constructor(t,e){this._schema=t;this._scheduler=e}project(t,...e){if(!this._schema)throw new Error("Schema not loaded");for(let r of e)this._dispatch(t,r)}_dispatch(t,e){let{path:r,value:c}=e,o=this._resolveEffect(r);o&&this._scheduler.enqueue({path:r.join("."),effect:o,ctx:{source:t,path:r,value:c}})}_resolveEffect(t){let e=this._schema;for(let r of t){if(!e)return null;e=e[r]}return typeof e=="function"?e:null}};var T=class{constructor(t){this._target=t}withTarget(t){return typeof t=="function"?this._targetFactory=t:this._target=t,this}checkTarget(){if(!this._target&&this._targetFactory&&(this._target=this._targetFactory()),!this._target)throw new Error("Scheduler: target is not set")}},S=class extends T{constructor(){super(...arguments);this._queue=new Map}enqueue(e){return this._queue.set(e.path,e),this}async flush(){this.checkTarget(),log.trace("BufferedScheduler: flushing");let e=[...this._queue.values()];this._queue.clear();for(let r of e){let{effect:c,ctx:o}=r,u=c(this._target,o);u instanceof Promise&&await u}}};function F(a){let t=new i(a);return[_(a,t.receive.bind(t),{pathAsArray:!0}),t]}export{S as BufferedScheduler,p as EffectBuilder,y as Projector,i as Recorder,T as Scheduler,F as track};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@cyysummer/projector",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A powerful state projection library for creating anything.",
   "license": "MIT",
   "author": "Chris Liu",
   "files": [
-    "dist/**",
+    "dist/*.js",
     "types/**"
   ],
   "type": "module",

package/types/lib.d.ts

@@ -1,8 +1,80 @@
+/**
+ * A Schema defines how to project changes from a source object to a target object.
+ */
+// prettier-ignore
+type Schema<TSource, T = any> = TSource extends object ?
+    Partial<{
+        // If the property is an array, map whole array to effect.
+        // Else map property to schema.
+        [K in keyof T]:
+        T[K] extends Array<infer U> ?
+        Effect<TSource, U>
+        // If TSource is an object, map each property to schema, or write effect for the property.
+        : Schema<TSource, T[K]> | Effect<TSource, T[K]>;
+    }>
+    // Else map T to effect.
+    : Effect<TSource, T>;
+
+/**
+ * An effect defines how to project a value from source to target.
+ */
+// todo: Solve this `any`
+type Effect<TSource, TValue> = (target: any, ctx: IEffectContext<TSource, TValue>) => MaybePromise<void>;
+
+/**
+ * The context for an effect. It contains information about changes.
+ */
+interface IEffectContext<TSource, TValue> {
+    /**
+     * The source object.
+     */
+    source?: TSource;
+    /**
+     * The path of the property.
+     */
+    path?: string;
+    /**
+     * The value of the property.
+     *
+     * If `source` or `path` is not specified, the value is passed from another effect.
+     */
+    value: TValue;
+}
+
+/**
+ * Strategy defines actual execution methods for projecting values to target.
+ */
+interface ITargetExecutionStrategy<TTarget, TLocation = any> {
+    execute<T>(target: TTarget, at: TLocation, value: T): MaybePromise<void>;
+    executeArray<T>(target: TTarget, at: TLocation, keys: Partial<keyof T>[], rows: T[]): MaybePromise<void>;
+}
+
+interface IProjector<TSource> {
+    project(next: TSource, ...patches: Patch[]): void;
+}
+
+interface IScheduler<TTarget> {
+    enqueue(effect: IScheduleItem): void;
+    flush(): MaybePromise<void>;
+    withTarget(target: TTarget): IScheduler<TTarget>;
+    withTarget(target: Func<TTarget>): IScheduler<TTarget>;
+}
+
+interface IScheduleItem<TSource, TValue> {
+    path: string;
+    effect: Effect<TSource, TValue>;
+    ctx: IEffectContext<TSource, TValue>;
+}
+
+interface Patch {
+    path: (string | symbol)[];
+    value: any;
+}
+
 type RecorderEvents = {
     record: {
         next: any;
-        path: any[];
-        value: any;
+        patches: Patch[];
     };
 };
 declare const Recorder_base: Constructor<object> & (new (...args: any[]) => object & IEventful<RecorderEvents>);
@@ -11,11 +83,30 @@ declare const Recorder_base: Constructor<object> & (new (...args: any[]) => obje
  */
 declare class Recorder<TSource extends object> extends Recorder_base {
     private _paused;
+    private _projector?;
+    private _projectorFactory?;
     private _shadow;
     constructor(initial: TSource);
-    record(path: any[], value: any): void;
+    /**
+     * Receive changes from the tracked object.
+     * @param path
+     * @param value
+     * @returns
+     */
+    receive(path: any[], value: any): void;
+    /**
+     * Send changes to a projector.
+     * @param projector
+     */
+    sendTo(projector: IProjector<TSource>): void;
+    /**
+     * Send changes to a projector.
+     * @param factory
+     */
+    sendTo(factory: Func<IProjector<TSource>>): void;
     pause(): void;
     resume(): void;
+    private _checkProjector;
 }
 
 /**
@@ -23,7 +114,7 @@ declare class Recorder<TSource extends object> extends Recorder_base {
  */
 declare class EffectBuilder<TTarget, TSource extends object> {
     private _strategy;
-    constructor(_strategy: ITargetStrategy<TTarget>);
+    constructor(_strategy: ITargetExecutionStrategy<TTarget>);
     /**
      * Call multiple effects in sequence.
      * @param effects Effects to call.
@@ -101,9 +192,9 @@ declare class Projector<TSource> implements IProjector<TSource> {
  * Scheduler abstract class, used to schedule projector effects.
  */
 declare abstract class Scheduler<TTarget> implements IScheduler<TTarget> {
-    protected _target: TTarget | null;
-    protected _targetFactory: Func<TTarget> | null;
-    constructor(_target?: TTarget | null);
+    protected _target?: TTarget | undefined;
+    protected _targetFactory?: Func<TTarget>;
+    constructor(_target?: TTarget | undefined);
     abstract enqueue(item: IScheduleItem<TTarget, any>): IScheduler<TTarget>;
     abstract flush(): MaybePromise<void>;
     withTarget(target: TTarget): IScheduler<TTarget>;
@@ -119,6 +210,11 @@ declare class BufferedScheduler<TTarget> extends Scheduler<TTarget> {
     flush(): Promise<void>;
 }
 
+/**
+ * Track changes to an object.
+ * @param initial Source object to track. This must the raw object, not reactive-enabled object.
+ * @returns A tuple of the tracked object and a recorder.
+ */
 declare function track<TSource extends object>(initial: TSource): [TSource, Recorder<TSource>];
 
 export { BufferedScheduler, EffectBuilder, Projector, Recorder, Scheduler, track };

package/types/types.d.ts

@@ -1,5 +1,8 @@
+/**
+ * A Schema defines how to project changes from a source object to a target object.
+ */
 // prettier-ignore
-type Schema<TSource, T = any> = TSource extends object ?
+export type Schema<TSource, T = any> = TSource extends object ?
     Partial<{
         // If the property is an array, map whole array to effect.
         // Else map property to schema.
@@ -12,10 +15,16 @@ type Schema<TSource, T = any> = TSource extends object ?
     // Else map T to effect.
     : Effect<TSource, T>;
 
+/**
+ * An effect defines how to project a value from source to target.
+ */
 // todo: Solve this `any`
-type Effect<TSource, TValue> = (target: any, ctx: IEffectContext<TSource, TValue>) => MaybePromise<void>;
+export type Effect<TSource, TValue> = (target: any, ctx: IEffectContext<TSource, TValue>) => MaybePromise<void>;
 
-interface IEffectContext<TSource, TValue> {
+/**
+ * The context for an effect. It contains information about changes.
+ */
+export interface IEffectContext<TSource, TValue> {
     /**
      * The source object.
      */
@@ -32,29 +41,32 @@ interface IEffectContext<TSource, TValue> {
     value: TValue;
 }
 
-interface ITargetStrategy<TTarget> {
-    execute<T>(target: TTarget, at: string, value: T): MaybePromise<void>;
-    executeArray<T>(target: TTarget, at: string, keys: Partial<keyof T>[], rows: T[]): MaybePromise<void>;
+/**
+ * Strategy defines actual execution methods for projecting values to target.
+ */
+export interface ITargetExecutionStrategy<TTarget, TLocation = any> {
+    execute<T>(target: TTarget, at: TLocation, value: T): MaybePromise<void>;
+    executeArray<T>(target: TTarget, at: TLocation, keys: Partial<keyof T>[], rows: T[]): MaybePromise<void>;
 }
 
-interface IProjector<TSource> {
+export interface IProjector<TSource> {
     project(next: TSource, ...patches: Patch[]): void;
 }
 
-interface IScheduler<TTarget> {
+export interface IScheduler<TTarget> {
     enqueue(effect: IScheduleItem): void;
     flush(): MaybePromise<void>;
     withTarget(target: TTarget): IScheduler<TTarget>;
     withTarget(target: Func<TTarget>): IScheduler<TTarget>;
 }
 
-interface IScheduleItem<TSource, TValue> {
+export interface IScheduleItem<TSource, TValue> {
     path: string;
     effect: Effect<TSource, TValue>;
     ctx: IEffectContext<TSource, TValue>;
 }
 
-interface Patch {
+export interface Patch {
     path: (string | symbol)[];
     value: any;
 }