@cyysummer/projector 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-PRESENT Chris Liu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Structural Data Projector
+
+结构化对象映射引擎

package/dist/index.js

@@ -0,0 +1,6 @@
+/**
+* @cyysummer/projector v0.0.2
+* (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};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@cyysummer/projector",
+  "version": "0.0.2",
+  "description": "A powerful state projection library for creating anything.",
+  "license": "MIT",
+  "author": "Chris Liu",
+  "files": [
+    "dist/**",
+    "types/**"
+  ],
+  "type": "module",
+  "module": "./dist/index.js",
+  "types": "./types",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./types/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "lodash-es": "^4.17.22",
+    "on-change": "^6.0.1",
+    "@cyysummer/core": "^0.0.12"
+  },
+  "peerDependencies": {
+    "@cyysummer/core": "^0.0.12"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.12",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.5",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "clean": "rm -rf ./dist",
+    "prebuild": "tsup --dts-only",
+    "build": "tsup --no-dts",
+    "postbuild": "mv -f dist/index.d.ts types/lib.d.ts",
+    "release": "pnpm run clean && pnpm run build",
+    "test": "vitest"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="../../core/types/index.d.ts" />
+/// <reference path="./lib.d.ts" />
+/// <reference path="./types.d.ts" />
+
+export * from "./lib";
+export * from "./types";
+
+export { };

package/types/lib.d.ts

@@ -0,0 +1,124 @@
+type RecorderEvents = {
+    record: {
+        next: any;
+        path: any[];
+        value: any;
+    };
+};
+declare const Recorder_base: Constructor<object> & (new (...args: any[]) => object & IEventful<RecorderEvents>);
+/**
+ * Record changes to an object.
+ */
+declare class Recorder<TSource extends object> extends Recorder_base {
+    private _paused;
+    private _shadow;
+    constructor(initial: TSource);
+    record(path: any[], value: any): void;
+    pause(): void;
+    resume(): void;
+}
+
+/**
+ * Build effects for a target.
+ */
+declare class EffectBuilder<TTarget, TSource extends object> {
+    private _strategy;
+    constructor(_strategy: ITargetStrategy<TTarget>);
+    /**
+     * Call multiple effects in sequence.
+     * @param effects Effects to call.
+     * @returns
+     */
+    chain<T>(effects: Effect<TSource, T>[]): Effect<TSource, T>;
+    /**
+     * Call multiple effects in sequence. Use `customizer` to transform the original value.
+     * @param effects Effects to call.
+     * @param customizer Function to transform the original value.
+     * @returns
+     */
+    chainWith<T, R>(effects: Effect<TSource, R>[], customizer: Func1<T, R>): Effect<TSource, R>;
+    /**
+     * Create an effect for the specified location.
+     * @param at The location in `TTarget` where the effect is to be executed.
+     * @returns
+     */
+    create<T>(at: string): Effect<TSource, T>;
+    /**
+     * Execute effect based on condition. The condition is based on the value of the current property path.
+     * @param condition Condition delegate that takes the original value of the property and returns true or false.
+     * @param whenTrue When condition is true, this effect is executed.
+     * @param whenFalse When condition is false, this effect is executed.
+     * @returns
+     */
+    createIf<T>(condition: Predicate<T>, whenTrue: Effect<TSource, any>, whenFalse?: Effect<TSource, any>): Effect<TSource, T>;
+    /**
+     * Execute effect based on condition. The condition is based on the source object.
+     * @param condition Condition delegate that takes the source object and returns true or false.
+     * @param whenTrue When condition is true, this effect is executed.
+     * @param whenFalse When condition is false, this effect is executed.
+     * @returns
+     */
+    createIfRoot<T>(condition: Predicate<TSource>, whenTrue: Effect<TSource, any>, whenFalse?: Effect<TSource, any>): Effect<TSource, T>;
+    /**
+     * Create an effect for the specified location. Use customizer to transform the source object.
+     * @param at The location in `TTarget` where the effect is to be executed.
+     * @param customizer Function to transform the source object.
+     * @returns
+     */
+    createRoot<T>(at: string, customizer: Func1<TSource, string>): Effect<TSource, T>;
+    /**
+     * Create an effect for the specified location for array data.
+     * @param at The location in `TTarget` where the effect is to be executed.
+     * @returns
+     */
+    createForArray<T extends Array<U>, U extends object = any>(at: string): Effect<TSource, T>;
+    /**
+     * Create an effect for the specified location for raw value. This will not read from source object.
+     * @param at The location in `TTarget` where the effect is to be executed.
+     * @param raw Raw value to use.
+     * @returns
+     */
+    createForRaw<T>(at: string, raw: T): Effect<TSource, T>;
+    /**
+     * Create an effect for the specified location. Use `customizer` to transform the source object.
+     * @param at The location in `TTarget` where the effect is to be executed.
+     * @param customizer Function to transform the source object.
+     * @returns
+     */
+    createWith<T, R>(at: string, customizer: Func1<T, R>): Effect<TSource, R>;
+}
+
+declare class Projector<TSource> implements IProjector<TSource> {
+    private _schema;
+    private _scheduler;
+    constructor(_schema: Schema<TSource>, _scheduler: IScheduler<any>);
+    project(next: TSource, ...patches: Patch[]): void;
+    private _dispatch;
+    private _resolveEffect;
+}
+
+/**
+ * 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);
+    abstract enqueue(item: IScheduleItem<TTarget, any>): IScheduler<TTarget>;
+    abstract flush(): MaybePromise<void>;
+    withTarget(target: TTarget): IScheduler<TTarget>;
+    withTarget(target: Func<TTarget>): IScheduler<TTarget>;
+    protected checkTarget(): void;
+}
+/**
+ * Buffered scheduler, will buffer effects and execute them in batch.
+ */
+declare class BufferedScheduler<TTarget> extends Scheduler<TTarget> {
+    protected readonly _queue: Map<string, IScheduleItem<TTarget, any>>;
+    enqueue(item: IScheduleItem<TTarget, any>): IScheduler<TTarget>;
+    flush(): Promise<void>;
+}
+
+declare function track<TSource extends object>(initial: TSource): [TSource, Recorder<TSource>];
+
+export { BufferedScheduler, EffectBuilder, Projector, Recorder, Scheduler, track };

package/types/types.d.ts

@@ -0,0 +1,60 @@
+// 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>;
+
+// todo: Solve this `any`
+type Effect<TSource, TValue> = (target: any, ctx: IEffectContext<TSource, TValue>) => MaybePromise<void>;
+
+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;
+}
+
+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>;
+}
+
+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;
+}