@cyysummer/projector 0.0.9 → 0.0.11

package/README.md

@@ -1,3 +1,51 @@
 # Structural Data Projector
 
 结构化对象映射引擎
+
+## Usage
+
+### Common
+
+
+```typescript
+interface IMyData {
+}
+
+const schema: Schema<IMyData> = {
+};
+
+class OutputTarget {
+}
+
+type TargetLocation = string;
+
+const strategy = new DemoStrategy(container);
+```
+
+### Svelte 5 with runes
+
+```typescript
+let initialState: IMyData = $state({});
+const builder = new Builder<IMyData, OutputTarget, TargetLocation>(initialState, schema)
+    .onFlush(() => {
+        // Do something when scheduler flushed. For example, update UI.
+    })
+    .withStrategy(strategy);
+const { tracked } = builder.buildStatic();
+let formData: IMyData = $derived(tracked);
+// bind `formData` to UI.
+```
+
+### Vue
+
+```typescript
+const initialState: IMyData = {};
+const builder = new Builder<IMyData, OutputTarget, TargetLocation>(initialState, schema)
+    .onFlush(() => {
+        // Do something when scheduler flushed. For example, update UI.
+    })
+    .withStrategy(strategy);
+const { tracked } = builder.buildStatic();
+const formData: IMyData = reactive(tracked);
+// bind `formData` to UI.
+```

package/dist/index.js

@@ -1,7 +1,7 @@
 /**
-* @cyysummer/projector v0.0.9
+* @cyysummer/projector v0.0.11
 * (c) 2021-PRESENT Chris Liu
 * @license MIT
 **/
-import w from"on-change";import{cloneDeep as m,set as x}from"lodash-es";import{withEvents as v}from"@cyysummer/core";var f=class extends v(){constructor(t){super();this._paused=!1;this._shadow=m(t)}receive(t,r){if(this._paused)return;x(this._shadow,t,r);let o=[{path:t,value:r}];this.emit("record",{next:this._shadow,patches:o}),this._ensureProjector(),this._projector?.project(this._shadow,...o)}sendTo(t){typeof t=="function"?this._projectorFactory=t:this._projector=t}pause(){this._paused=!0}resume(){this._paused=!1}_ensureProjector(){!this._projector&&this._projectorFactory&&(this._projector=this._projectorFactory())}};import{get as p,keys as l}from"lodash-es";var S=n=>{},d=class{at(e){return(t,r)=>{let o=i(r);return t.execute(e,o)}}atWith(e,t){return(o,c)=>{let a=i(c),u=t(a);return o.execute(e,u)}}arrayAt(e,t){return(r,o)=>{let c=o.path?p(o.source,o.path):o.value;if(c&&Array.isArray(c)&&c.length>0){let a={keys:typeof c[0]=="object"?l(c[0]):[],resolveHeader:(u,s)=>String(u),...t};return r.executeArray(e,c,a)}}}arrayAtWith(e,t,r){return(o,c)=>{let a=c.path?p(c.source,c.path):c.value;if(a&&Array.isArray(a)&&a.length>0){let u=a.map(t),s={keys:typeof a[0]=="object"?l(a[0]):[],resolveHeader:(T,j)=>String(T),...r};return o.executeArray(e,u,s)}}}loop(e){return async(t,r)=>{let o=i(r);if(Array.isArray(o)){let c=o;for(let a=0;a<c.length;a++){let u=c[a],T=e(u,a)(t,{value:u});T instanceof Promise&&await T}}else throw new Error(`Effect: Value at path '${r.path}' is not an array.`)}}sourceWith(e,t){return(r,o)=>{let c=t(o.source);return r.execute(e,c)}}raw(e,t){return(r,o)=>r.execute(e,t)}sequence(e){return async(t,r)=>{let o=i(r);for(let c of e)await c(t,{value:o})}}sequenceWith(e,t){return async(o,c)=>{let a=i(c),u=t(a);for(let s of e)await s(o,{value:u})}}when(e,t,r=S){return(o,c)=>{let a=i(c);return(e(a)?t:r)(o,{value:a})}}whenFromSource(e,t,r=S){return(o,c)=>(e(c.source)?t:r)(o,c)}},i=n=>n.source&&n.path?p(n.source,n.path):n.value;var h=class{constructor(e){this._schema=e;if(!e)throw new Error("Projector: Schema is required.")}project(e,...t){for(let r of t)this._dispatch(e,r)}_dispatch(e,t){let{path:r,value:o}=t,c=this._resolveEffect(r);c&&(this._ensureScheduler(),this._scheduler.enqueue({path:r.join("."),effect:c,ctx:{source:e,path:r,value:o}}))}_ensureScheduler(){if(!this._scheduler)throw new Error("Projector: no scheduler.")}_resolveEffect(e){let t=this._schema;for(let r of e){if(!t)return null;t=t[r]}return typeof t=="function"?t:null}},g=class extends h{constructor(e,t){super(e),this._scheduler=t}},E=class extends h{scheduleWith(e){return typeof e=="function"?this._schedulerFactory=e:this._scheduler=e,this}_ensureScheduler(){if(!this._scheduler&&this._schedulerFactory&&(this._scheduler=this._schedulerFactory()),!this._scheduler)throw new Error("Projector: no scheduler.")}};import{debounce as b}from"lodash-es";var y=class{constructor(e){this._strategy=e;this._queue=new Map}enqueue(e){return this._queue.set(e.path,e),this}flush(){return this.checkStrategy(),log.trace("Scheduler.flush()",[...this._queue.keys()]),this.flushCore()}withStrategy(e){return typeof e=="function"?this._strategyFactory=e:this._strategy=e,this}checkStrategy(){if(!this._strategy&&this._strategyFactory&&(this._strategy=this._strategyFactory()),!this._strategy)throw new Error("Scheduler: target is not set")}async run(e){for(let t of e){let{effect:r,ctx:o}=t,c=r(this._strategy,o);c instanceof Promise&&await c}}},I=class extends y{constructor(t,r=500){super(t);this.timeout=r;this.flushCore=b(async()=>{let t=[...this._queue.values()];this._queue.clear(),this.run(t)},this.timeout)}},_=class extends y{async flushCore(){this._strategy.reset(),this.run([...this._queue.values()])}};function O(n){let e=new f(n);return[w(n,(r,o)=>e.receive(r,o),{pathAsArray:!0}),e]}export{E as DynamicProjector,d as EffectFactory,I as LazyScheduler,g as Projector,h as ProjectorBase,f as Recorder,y as Scheduler,_ as TotalScheduler,O as track};
+import k from"on-change";import{cloneDeep as v,debounce as F,set as E}from"lodash-es";import{withEvents as j}from"@cyysummer/core";var f=class extends j(){constructor(t){super();this._paused=!1;this._shadow=v(t)}sendTo(t){this._projectorFactory=typeof t=="function"?t:()=>t}pause(){this._paused=!0}resume(){this._paused=!1}},i=class extends f{receive(e,t){if(this._paused)return;E(this._shadow,e,t);let r=[{path:e,value:t}];this._projectorFactory?.()?.project(this._shadow,...r),this.emit("record",{next:this._shadow,patches:r})}},d=class extends f{constructor(t,r=500){super(t);this._wait=r;this._buffer=new Map;this.receiveCore=F(()=>{let t=[...this._buffer.values()];log.trace("LazyRecorder.receiveCore,",t),this._buffer.clear();for(let r of t)E(this._shadow,r.path,r.value);this._projectorFactory?.()?.project(this._shadow,...t),this.emit("record",{next:this._shadow,patches:t})},this._wait,{trailing:!0})}receive(t,r){this._paused||(this._buffer.set(t.join("."),{path:t,value:r}),this.receiveCore())}};import P from"on-change";var y=class{constructor(e,t){this._schema=e;this._scheduler=t;if(!e)throw new Error("Projector: Schema is required.")}project(e,...t){for(let r of t)this._dispatch(e,r)}_dispatch(e,t){let{path:r,value:o}=t,c=this._resolveEffect(r);c&&(this._ensureScheduler(),this._scheduler.enqueue({path:r.join("."),effect:c,ctx:{source:e,path:r,value:o}}))}_ensureScheduler(){if(!this._scheduler)throw new Error("Projector: no scheduler.")}_resolveEffect(e){let t=this._schema;for(let r of e){if(!t)return null;t=t[r]}return typeof t=="function"?t:null}},p=class extends y{constructor(e,t){super(e,t)}},S=class extends y{withScheduler(e){return typeof e=="function"?this._schedulerFactory=e:this._scheduler=e,this}_ensureScheduler(){if(!this._scheduler&&this._schedulerFactory&&(this._scheduler=this._schedulerFactory()),!this._scheduler)throw new Error("Projector: no scheduler.")}};import{debounce as L}from"lodash-es";var g=class{constructor(e){this._queue=new Map;e&&(this._strategyFactory=()=>e)}enqueue(e){return this._queue.set(e.path,e),this}flush(){return log.trace("Scheduler.flush()",[...this._queue.keys()]),this.flushCore()}reset(){this._queue.clear()}withStrategy(e){return this._strategyFactory=typeof e=="function"?e:()=>e,this}ensureStrategy(){let e=this._strategyFactory?.();if(!e)throw new Error("Scheduler: no strategy.");return e}async run(e){for(let t of e){let{effect:r,ctx:o}=t,c=r(this.ensureStrategy(),o);c instanceof Promise&&await c}}},h=class extends g{constructor(t,r=500){super(t);this.wait=r;this.flushCore=L(async()=>{let t=[...this._queue.values()];this._queue.clear(),this.run(t)},this.wait)}},_=class extends g{async flushCore(){this.ensureStrategy().reset(),this.run([...this._queue.values()])}};import{debounce as C}from"lodash-es";var b=class{constructor(e,t,r=500){this._initial=e;this._schema=t;this._waitTime=r;if(!e||!t||!r)throw new Error("Builder: all params are required.");if(Number(r)<0)throw new Error("Builder: wait time must be >= 0.")}buildDynamic(){this.track();let e=new S(this._schema);return this._scheduler&&e.withScheduler(this._scheduler),this._recorder.sendTo(e),{tracked:this._tracked,recorder:this._recorder,projector:e,scheduler:this._scheduler}}buildStatic(){if(!this._strategy&&!this._strategyFactory)throw new Error("Builder: no strategy was provided. Call `withStrategy()` to provide.");this._scheduler||(this._scheduler=new h),this._flushCallback||log.warn("Builder: no flush callback was provided.");let e=async()=>{await this._scheduler.flush(),this._flushCallback?.()};this.track(),this._scheduler.withStrategy(this._strategy??this._strategyFactory);let t=new p(this._schema,this._scheduler);return this._recorder.sendTo(t),this._recorder.on("record",this._waitTime?C(e,this._waitTime):e),{tracked:this._tracked,recorder:this._recorder,scheduler:this._scheduler}}onFlush(e){return this._flushCallback=e,this}withLazyScheduler(e=500){return this._scheduler=new h(void 0,e),this}withTotalScheduler(){return this._scheduler=new _,this}withStrategy(e){return typeof e=="function"?this._strategyFactory=e:this._strategy=e,this}track(){this._recorder&&this._tracked||(this._recorder=this._waitTime>0?new d(this._initial,this._waitTime):new i(this._initial),this._tracked=P(this._initial,(e,t)=>this._recorder.receive(e,t),{pathAsArray:!0}))}};import{get as m,keys as w}from"lodash-es";var I=u=>{},x=class{at(e){return(t,r)=>{let o=T(r);return t.execute(e,o)}}atWith(e,t){return(o,c)=>{let a=T(c),s=t(a);return o.execute(e,s)}}arrayAt(e,t){return(r,o)=>{let c=o.path?m(o.source,o.path):o.value;if(c&&Array.isArray(c)&&c.length>0){let a={keys:typeof c[0]=="object"?w(c[0]):[],resolveHeader:(s,n)=>String(s),...t};return r.executeArray(e,c,a)}}}arrayAtWith(e,t,r){return(o,c)=>{let a=c.path?m(c.source,c.path):c.value;if(a&&Array.isArray(a)&&a.length>0){let s=a.map(t),n={keys:typeof a[0]=="object"?w(a[0]):[],resolveHeader:(l,A)=>String(l),...r};return o.executeArray(e,s,n)}}}loop(e){return async(t,r)=>{let o=T(r);if(Array.isArray(o)){let c=o;for(let a=0;a<c.length;a++){let s=c[a],l=e(s,a)(t,{value:s});l instanceof Promise&&await l}}else throw new Error(`Effect: Value at path '${r.path}' is not an array.`)}}sourceWith(e,t){return(r,o)=>{let c=t(o.source);return r.execute(e,c)}}raw(e,t){return(r,o)=>r.execute(e,t)}sequence(e){return async(t,r)=>{let o=T(r);for(let c of e)await c(t,{value:o})}}sequenceWith(e,t){return async(o,c)=>{let a=T(c),s=t(a);for(let n of e)await n(o,{value:s})}}when(e,t,r=I){return(o,c)=>{let a=T(c);return(e(a)?t:r)(o,{value:a})}}whenFromSource(e,t,r=I){return(o,c)=>(e(c.source)?t:r)(o,c)}},T=u=>u.source&&u.path?m(u.source,u.path):u.value;function X(u){let e=new i(u);return[k(u,(r,o)=>e.receive(r,o),{pathAsArray:!0}),e]}export{b as Builder,S as DynamicProjector,x as EffectFactory,d as LazyRecorder,h as LazyScheduler,p as Projector,y as ProjectorBase,i as Recorder,f as RecorderBase,g as Scheduler,_ as TotalScheduler,X as track};
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyysummer/projector",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "A powerful state projection library for creating anything.",
   "license": "MIT",
   "author": "Chris Liu",

package/types/lib.d.ts

@@ -59,10 +59,11 @@ type ArrayEffectOptions = {
 /**
  * Strategy defines actual execution methods for projecting values to target.
  */
-interface ITargetExecutionStrategy<TTarget, TLocation = any> {
+interface ITargetExecutionStrategy<TTarget, TLocation> {
     execute<T extends any>(location: TLocation, value: T): MaybePromise<void>;
     executeArray<T extends any>(location: TLocation, rows: T[], options: ArrayEffectOptions): MaybePromise<void>;
     reset(): void;
+    get target(): TTarget;
 }
 
 interface IProjector<TSource> {
@@ -72,8 +73,9 @@ interface IProjector<TSource> {
 interface IScheduler<TTarget> {
     enqueue(effect: IScheduleItem): void;
     flush(): MaybePromise<void>;
-    withStrategy(target: ITargetExecutionStrategy<TTarget, unknown>): IScheduler<TTarget>;
-    withStrategy(target: Func<ITargetExecutionStrategy<TTarget, unknown>>): IScheduler<TTarget>;
+    reset(): void;
+    withStrategy(strategy: ITargetExecutionStrategy<TTarget, any>): IScheduler<TTarget>;
+    withStrategy(factory: Func<ITargetExecutionStrategy<TTarget, any>>): IScheduler<TTarget>;
 }
 
 interface IScheduleItem<TSource, TValue> {
@@ -93,15 +95,14 @@ type RecorderEvents = {
         patches: Patch[];
     };
 };
-declare const Recorder_base: Constructor<object> & (new (...args: any[]) => object & IEventful<RecorderEvents>);
+declare const RecorderBase_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 _projector?;
-    private _projectorFactory?;
-    private _shadow;
+declare abstract class RecorderBase<TSource extends object> extends RecorderBase_base {
+    protected _paused: boolean;
+    protected _projectorFactory?: Func<IProjector<TSource>>;
+    protected _shadow: TSource;
     constructor(initial: TSource);
     /**
      * Receive changes from the tracked object.
@@ -109,7 +110,7 @@ declare class Recorder<TSource extends object> extends Recorder_base {
      * @param value
      * @returns
      */
-    receive(path: any[], value: any): void;
+    abstract receive(path: any[], value: any): void;
     /**
      * Send changes to a projector.
      * @param projector
@@ -122,7 +123,82 @@ declare class Recorder<TSource extends object> extends Recorder_base {
     sendTo(factory: Func<IProjector<TSource>>): void;
     pause(): void;
     resume(): void;
-    private _ensureProjector;
+}
+declare class Recorder<TSource extends object> extends RecorderBase<TSource> {
+    /**
+     * Receive changes from the tracked object.
+     * @param path
+     * @param value
+     * @returns
+     */
+    receive(path: any[], value: any): void;
+}
+declare class LazyRecorder<TSource extends object> extends RecorderBase<TSource> {
+    protected _wait: number;
+    protected _buffer: Map<string, Patch>;
+    constructor(initial: TSource, _wait?: number);
+    /**
+     * Receive changes from the tracked object.
+     * @param path
+     * @param value
+     * @returns
+     */
+    receive(path: any[], value: any): void;
+    protected readonly receiveCore: lodash_es.DebouncedFunc<() => void>;
+}
+
+declare abstract class ProjectorBase<TSource> implements IProjector<TSource> {
+    protected _schema: Schema<TSource>;
+    protected _scheduler?: IScheduler<any> | undefined;
+    constructor(_schema: Schema<TSource>, _scheduler?: IScheduler<any> | undefined);
+    project(next: TSource, ...patches: Patch[]): void;
+    protected _dispatch(next: TSource, patch: Patch): void;
+    protected _ensureScheduler(): void;
+    protected _resolveEffect(path: (string | symbol)[]): Effect<TSource, any> | null;
+}
+declare class Projector<TSource> extends ProjectorBase<TSource> {
+    constructor(_schema: Schema<TSource>, _scheduler: IScheduler<any>);
+}
+declare class DynamicProjector<TSource> extends ProjectorBase<TSource> {
+    private _schedulerFactory?;
+    withScheduler(scheduler: IScheduler<any>): IProjector<TSource>;
+    withScheduler(factory: Func<IScheduler<any>>): IProjector<TSource>;
+    protected _ensureScheduler(): void;
+}
+
+declare class Builder<TSource extends object, TTarget, TLocation> {
+    private _initial;
+    private _schema;
+    private _waitTime;
+    private _flushCallback?;
+    private _recorder?;
+    private _scheduler?;
+    private _strategy?;
+    private _strategyFactory?;
+    private _tracked?;
+    constructor(_initial: TSource, _schema: Schema<TSource>, _waitTime?: number);
+    buildDynamic(): {
+        tracked: TSource;
+        recorder: RecorderBase<TSource>;
+        projector: DynamicProjector<TSource>;
+        scheduler: IScheduler<TTarget> | undefined;
+    };
+    buildStatic(): {
+        tracked: TSource;
+        recorder: RecorderBase<TSource>;
+        scheduler: IScheduler<TTarget>;
+    };
+    /**
+     * Provide a callback to execute after scheduler flushed.
+     * @param callback
+     * @returns
+     */
+    onFlush(callback: Action): Builder<TSource, TTarget, TLocation>;
+    withLazyScheduler(wait?: number): Builder<TSource, TTarget, TLocation>;
+    withTotalScheduler(): Builder<TSource, TTarget, TLocation>;
+    withStrategy(strategy: ITargetExecutionStrategy<TTarget, TLocation>): Builder<TSource, TTarget, TLocation>;
+    withStrategy(factory: Func<ITargetExecutionStrategy<TTarget, TLocation>>): Builder<TSource, TTarget, TLocation>;
+    private track;
 }
 
 /**
@@ -209,45 +285,26 @@ declare class EffectFactory<TSource extends object, TLocation = any> {
     whenFromSource<T>(condition: Predicate<TSource>, ifTrue: Effect<TSource, any>, ifFalse?: Effect<TSource, any>): Effect<TSource, T>;
 }
 
-declare abstract class ProjectorBase<TSource> implements IProjector<TSource> {
-    protected _schema: Schema<TSource>;
-    protected _scheduler?: IScheduler<any>;
-    constructor(_schema: Schema<TSource>);
-    project(next: TSource, ...patches: Patch[]): void;
-    protected _dispatch(next: TSource, patch: Patch): void;
-    protected _ensureScheduler(): void;
-    protected _resolveEffect(path: (string | symbol)[]): Effect<TSource, any> | null;
-}
-declare class Projector<TSource> extends ProjectorBase<TSource> {
-    constructor(_schema: Schema<TSource>, _scheduler: IScheduler<any>);
-}
-declare class DynamicProjector<TSource> extends ProjectorBase<TSource> {
-    private _schedulerFactory?;
-    scheduleWith(scheduler: IScheduler<any>): IProjector<TSource>;
-    scheduleWith(schedulerFactory: Func<IScheduler<any>>): IProjector<TSource>;
-    protected _ensureScheduler(): void;
-}
-
 /**
  * Scheduler abstract class, used to schedule projector effects.
  */
 declare abstract class Scheduler<TTarget> implements IScheduler<TTarget> {
-    protected _strategy?: ITargetExecutionStrategy<TTarget, any> | undefined;
     protected readonly _queue: Map<string, IScheduleItem<any, any>>;
     protected _strategyFactory?: Func<ITargetExecutionStrategy<TTarget, any>>;
-    constructor(_strategy?: ITargetExecutionStrategy<TTarget, any> | undefined);
+    constructor(strategy?: ITargetExecutionStrategy<TTarget, any>);
     enqueue(item: IScheduleItem<any, any>): IScheduler<TTarget>;
     flush(): MaybePromise<void>;
+    reset(): void;
     withStrategy(strategy: ITargetExecutionStrategy<TTarget, any>): IScheduler<TTarget>;
-    withStrategy(strategy: Func<ITargetExecutionStrategy<TTarget, any>>): IScheduler<TTarget>;
-    protected checkStrategy(): void;
+    withStrategy(factory: Func<ITargetExecutionStrategy<TTarget, any>>): IScheduler<TTarget>;
+    protected ensureStrategy(): ITargetExecutionStrategy<TTarget, any>;
     protected abstract flushCore(): MaybePromise<void>;
     protected run(list: IScheduleItem<any, any>[]): Promise<void>;
 }
 /**
  * A scheduler that **delays and batches** effect executions using debounce.
  *
- * Effects are collected in a queue and only executed after the specified `timeout`
+ * Effects are collected in a queue and only executed after the specified `wait`
  * has passed without any new effects being enqueued. This helps reduce redundant
  * executions (e.g. during rapid successive state updates) and is especially useful
  * when projecting to expensive targets like UI rendering, DOM updates, or network requests.
@@ -257,8 +314,8 @@ declare abstract class Scheduler<TTarget> implements IScheduler<TTarget> {
  * effects in batch.
  */
 declare class LazyScheduler<TTarget> extends Scheduler<TTarget> {
-    protected timeout: number;
-    constructor(strategy?: ITargetExecutionStrategy<TTarget, any>, timeout?: number);
+    protected wait: number;
+    constructor(strategy?: ITargetExecutionStrategy<TTarget, any>, wait?: number);
     protected readonly flushCore: lodash_es.DebouncedFunc<() => Promise<void>>;
 }
 /**
@@ -275,4 +332,4 @@ declare class TotalScheduler<TTarget> extends Scheduler<TTarget> {
  */
 declare function track<TSource extends object>(initial: TSource): [TSource, Recorder<TSource>];
 
-export { DynamicProjector, EffectFactory, LazyScheduler, Projector, ProjectorBase, Recorder, Scheduler, TotalScheduler, track };
+export { Builder, DynamicProjector, EffectFactory, LazyRecorder, LazyScheduler, Projector, ProjectorBase, Recorder, RecorderBase, Scheduler, TotalScheduler, track };

package/types/types.d.ts

@@ -57,10 +57,11 @@ export type ArrayEffectOptions = {
 /**
  * Strategy defines actual execution methods for projecting values to target.
  */
-export interface ITargetExecutionStrategy<TTarget, TLocation = any> {
+export interface ITargetExecutionStrategy<TTarget, TLocation> {
     execute<T extends any>(location: TLocation, value: T): MaybePromise<void>;
     executeArray<T extends any>(location: TLocation, rows: T[], options: ArrayEffectOptions): MaybePromise<void>;
     reset(): void;
+    get target(): TTarget;
 }
 
 export interface IProjector<TSource> {
@@ -70,8 +71,9 @@ export interface IProjector<TSource> {
 export interface IScheduler<TTarget> {
     enqueue(effect: IScheduleItem): void;
     flush(): MaybePromise<void>;
-    withStrategy(target: ITargetExecutionStrategy<TTarget, unknown>): IScheduler<TTarget>;
-    withStrategy(target: Func<ITargetExecutionStrategy<TTarget, unknown>>): IScheduler<TTarget>;
+    reset(): void;
+    withStrategy(strategy: ITargetExecutionStrategy<TTarget, any>): IScheduler<TTarget>;
+    withStrategy(factory: Func<ITargetExecutionStrategy<TTarget, any>>): IScheduler<TTarget>;
 }
 
 export interface IScheduleItem<TSource, TValue> {