@peter.naydenov/cuts 2.1.0 → 2.1.2

package/test/02-cuts.test.js

@@ -252,6 +252,30 @@ describe ( 'Cuts integration', () => {
 
 
 
+     it ( 'List shortcuts excludes beforeHide and afterShow', async () => {
+                     // Regression test: listShortcuts used to destructure the old
+                     // 'beforeUnload'/'afterLoad' names, so the real 'beforeHide'/'afterShow'
+                     // scene methods leaked into the returned shortcuts list.
+                     const script = cuts ()
+                     const scenes = [
+                                     {
+                                           name: 'top'
+                                         , scene: {
+                                                     show       : ({task}) => task.done(),
+                                                     hide       : ({task}) => task.done(),
+                                                     beforeHide : ({ done }) => done ( true ),
+                                                     afterShow  : () => {},
+                                                     'click: left-1' : () => {}
+                                             }
+                                         }
+                                 ];
+
+                     script.setScenes ( scenes )
+                     expect ( script.listShortcuts( 'top' ) ).toEqual ( ['click: left-1'] )
+         }) // it List shortcuts excludes beforeHide and afterShow
+
+
+
      it ( 'Jump functionality', async () => {
                      const script = cuts({ logLevel : 0 });
                      const calls = [];
@@ -409,4 +433,149 @@ describe ( 'Cuts integration', () => {
 
 
 
+     it ( 'Show scene with wildcard parent as the very first scene', async () => {
+                     // Regression test: state.currentParents starts as null, and the
+                     // wildcard branch used to push into it before it was initialized,
+                     // crashing on the first-ever show() call.
+                     const script = cuts();
+                     const calls = [];
+                     const scenes = [
+                                     {
+                                           name: 'overlay'
+                                         , scene: {
+                                                     show: ({task}) => { calls.push('show overlay'); task.done() },
+                                                     hide: ({task}) => { calls.push('hide overlay'); task.done() },
+                                                     parents: ['*']
+                                             }
+                                         }
+                                 ];
+
+                     script.setScenes ( scenes );
+
+                     await script.show ({ scene: 'overlay' });
+                     expect ( calls ).toEqual (['show overlay']);
+                     expect ( script.getState().scene ).toEqual ( 'overlay' );
+                     expect ( script.getState().parents ).toEqual ( [null] ); // No previous scene, saved as null
+         }) // it Show scene with wildcard parent as the very first scene
+
+
+
+     it ( 'Hide with wildcard steps resets state to the root', async () => {
+                     // Regression test: hide('*') used to hide every scene correctly but left
+                     // 'currentScene'/'currentParents' stale instead of resetting them to the root.
+                     const calls = [];
+                     const script = cuts();
+                     const scenes = [
+                                     { name: 'top' , scene: { show: ({task}) => { calls.push('show top');  task.done() }, hide: ({task}) => { calls.push('hide top');  task.done() } } },
+                                     { name: 'mid' , scene: { show: ({task}) => { calls.push('show mid');  task.done() }, hide: ({task}) => { calls.push('hide mid');  task.done() }, parents: ['top'] } },
+                                     { name: 'deep', scene: { show: ({task}) => { calls.push('show deep'); task.done() }, hide: ({task}) => { calls.push('hide deep'); task.done() }, parents: ['top', 'mid'] } }
+                                 ];
+
+                     script.setScenes ( scenes );
+                     await script.show ({ scene: 'deep' });
+                     calls.length = 0;
+
+                     await script.hide ( '*' );
+                     expect ( calls ).toEqual ([ 'hide deep', 'hide mid', 'hide top' ]);
+                     expect ( script.getState() ).toEqual ({ scene: null, parents: [], opened: true });
+         }) // it Hide with wildcard steps resets state to the root
+
+
+
+     it ( 'emit() passes args through without an injected context object', async () => {
+                     // Regression test: shortcuts@4.1.1's own emit() now prepends a
+                     // { dependencies, type: 'custom' } object to support event chaining.
+                     // cuts.emit() must keep forwarding exactly what the caller passed.
+                     const received = [];
+                     const script = cuts();
+                     const scenes = [
+                                     {
+                                           name: 'top'
+                                         , scene: {
+                                                     show : ({task}) => task.done(),
+                                                     hide : ({task}) => task.done(),
+                                                     '@custom-event' : ( payload ) => received.push ( payload )
+                                             }
+                                         }
+                                 ];
+
+                     script.setScenes ( scenes );
+                     await script.show ({ scene: 'top' });
+
+                     script.emit ( '@custom-event', { foo: 'bar' } );
+                     expect ( received ).toEqual ([{ foo: 'bar' }]);
+         }) // it emit() passes args through without an injected context object
+
+
+
+     it ( 'Wildcard overlay scene activates its own shortcuts context', async () => {
+                     // Regression test: showing a '*'-parented scene never switched the
+                     // shortcuts context to it, so its own shortcut/event handlers never fired.
+                     const seen = [];
+                     const script = cuts();
+                     const scenes = [
+                                     {
+                                           name: 'base'
+                                         , scene: {
+                                                     show : ({task}) => task.done(),
+                                                     hide : ({task}) => task.done(),
+                                                     '@ping' : () => seen.push ( 'base' )
+                                             }
+                                         },
+                                         {
+                                           name: 'overlay'
+                                         , scene: {
+                                                     show : ({task}) => task.done(),
+                                                     hide : ({task}) => task.done(),
+                                                     parents: ['*'],
+                                                     '@ping' : () => seen.push ( 'overlay' )
+                                             }
+                                         }
+                                 ];
+
+                     script.setScenes ( scenes );
+                     await script.show ({ scene: 'base' });
+                     await script.show ({ scene: 'overlay' });
+
+                     script.emit ( '@ping' );
+                     expect ( seen ).toEqual ([ 'overlay' ]);
+         }) // it Wildcard overlay scene activates its own shortcuts context
+
+
+
+     it ( 'Showing a wildcard overlay does not corrupt the underlying scene, and returning to it works', async () => {
+                     // Regression test: state.currentParents used to be aliased directly to a
+                     // scene's own 'parents' array, so pushing onto it (done when showing a
+                     // wildcard overlay) permanently mutated that scene's 'parents' definition -
+                     // which then crashed when navigating back to it.
+                     const calls = [];
+                     const script = cuts();
+                     const baseScene = {
+                                           show : ({task}) => { calls.push('show base'); task.done() }
+                                         , hide : ({task}) => { calls.push('hide base'); task.done() }
+                                     };
+                     const scenes = [
+                                     { name: 'base', scene: baseScene },
+                                     {
+                                           name: 'overlay'
+                                         , scene: {
+                                                     show : ({task}) => { calls.push('show overlay'); task.done() },
+                                                     hide : ({task}) => { calls.push('hide overlay'); task.done() },
+                                                     parents: ['*']
+                                             }
+                                         }
+                                 ];
+
+                     script.setScenes ( scenes );
+                     await script.show ({ scene: 'base' });
+                     await script.show ({ scene: 'overlay' });
+
+                     expect ( baseScene.parents ).toEqual ([]); // Not corrupted into ['base']
+
+                     await script.show ({ scene: 'base' }); // Used to throw
+                     expect ( script.getState() ).toEqual ({ scene: 'base', parents: [], opened: true });
+         }) // it Showing a wildcard overlay does not corrupt the underlying scene, and returning to it works
+
+
+
  }) // describe

package/types/findInstructions.d.ts

@@ -1,4 +1,3 @@
-export default findInstructions;
 /**
  * @function findInstructions
  * @description Generator that yields instructions for transitioning between scenes
@@ -9,4 +8,5 @@ export default findInstructions;
  * @yields {Array.<string, 'show'|'hide'>} - instruction array with scene name and action
  */
 declare function findInstructions(currentName: string | null, currentParents: Array<string>, targetName: string, targetParents: Array<string>): Generator<string[], void, unknown>;
+export default findInstructions;
 //# sourceMappingURL=findInstructions.d.ts.map

package/types/findInstructions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findInstructions.d.ts","sourceRoot":"","sources":["../src/findInstructions.js"],"names":[],"mappings":";AAGA;;;;;;;;GAQG;AACH,+CANW,MAAM,GAAC,IAAI,kBACX,KAAK,CAAE,MAAM,CAAC,cACd,MAAM,iBACN,KAAK,CAAE,MAAM,CAAC,sCAyExB"}
+{"version":3,"file":"findInstructions.d.ts","sourceRoot":"","sources":["../src/findInstructions.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,iBAAU,gBAAgB,CAAG,WAAW,EAN7B,MAAM,GAAC,IAMsB,EAAE,cAAc,EAL7C,KAAK,CAAE,MAAM,CAKgC,EAAE,UAAU,EAJzD,MAIyD,EAAE,aAAa,EAHxE,KAAK,CAAE,MAAM,CAG2D,sCAsElF;eAIc,gBAAgB"}

package/types/main.d.ts

@@ -1,4 +1,3 @@
-export default main;
 declare function main(cfg?: {
     logLevel: number;
 }): {
@@ -9,23 +8,88 @@ declare function main(cfg?: {
         scene: string;
         options?: {
             ssr: boolean;
-        } | undefined;
+        };
     }, ...args?: any[]) => Promise<any>;
     jump: ({ scene }: {
         scene: string;
     }, ...args?: any[]) => Promise<any>;
     jumpBack: ({ hops }?: {
-        hops?: number | undefined;
+        hops?: number;
     }, ...args?: any[]) => Promise<any> | undefined;
     jumpsReset: () => void;
-    loadPlugins(plugins: Array<"Key" | "Click" | "Form" | "Hover" | "Scroll">): Promise<Function[]>;
-    setDependencies(deps: any): void;
-    getDependencies(): any;
-    setNote(note: string): void;
-    listScenes(): Array<string>;
-    enablePlugin(plugin: Function, options?: any): void;
-    disablePlugin(pluginName: string): void;
-    getState(): Object;
-    emit(event: string, ...args: any[]): void;
+    /**
+     * @typedef {'Key'|'Click'|'Form'|'Hover'|'Scroll' } pluginNames
+     * @description List of possible plugin names: 'Key', 'Click', 'Form', 'Hover', 'Scroll'
+     *
+     * Load a needed shortcut plugins - 'Key', 'Click', 'Form', 'Hover', 'Scroll' and so on.
+     * It's a async function. Don't forget to 'await' it.
+     * @function loadPlugins
+     * @param {Array.<pluginNames>} plugins - list of plugins to load
+     * @returns {Promise.<function[]>} - loaded plugins in a sequence
+     *
+     * @example
+     * // script is instance of cuts
+     * await script.loadPlugins ( ['Key', 'Click'] )
+     *             .then ( plugins => plugins.forEach ( plugin => script.enablePlugin ( plugin ) ) )
+     */
+    loadPlugins: (plugins: Array<"Click" | "Form" | "Hover" | "Key" | "Scroll">) => Promise<Function[]>;
+    /**
+     * @function setDependencies
+     * @description Set dependencies for the Scenes
+     * @param {*} deps - dependencies objects
+     * @returns void
+     */
+    setDependencies: (deps: any) => void;
+    /**
+     * @function getDependencies
+     * @description Get dependencies for the Scenes
+     * @returns {*} - dependencies objects
+     */
+    getDependencies: () => any;
+    /**
+     * @function setNote
+     * @param {string} note - note, provided to action functions
+     * @returns void
+     */
+    setNote: (note: string) => void;
+    /**
+     * @function listScenes
+     * @description List all loaded Scene names
+     * @returns {Array.<string>} - list of scene names
+     */
+    listScenes: () => Array<string>;
+    /**
+     * @function enablePlugin
+     * @description Enable a shortcut plugin
+     * @param {function} plugin - plugin library
+     * @param {*} [options] - plugin options
+     * @returns void
+     */
+    enablePlugin: (plugin: Function, options?: any) => void;
+    /**
+     * Disable a shortcut plugin
+     * @function disablePlugin
+     * @param {string} pluginName - plugin name
+     * @returns void
+     */
+    disablePlugin: (pluginName: string) => void;
+    /**
+     * Get the current state of the application
+     * @function getState
+     * @returns {Object} with properties:
+     *  - scene: current scene name
+     *  - parents: current parent scene names
+     *  - opened: boolean indicating if the application is opened
+     */
+    getState: () => Object;
+    /**
+     * @function emit
+     * @description Emit an event
+     * @param {string} event - event name
+     * @param {...*} args - Extra data to pass to the listeners
+     * @returns void
+     */
+    emit: (event: string, ...args: any[]) => any;
 };
+export default main;
 //# sourceMappingURL=main.d.ts.map

package/types/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.js"],"names":[],"mappings":";AAsCA;;;;;;;;;;;;;;;;;;;yBA8CmB,KAAK,+CAAc,GACjB,OAAO,CAAE,UAAU,CAAC;0BAgBtB,GAAC;uBAQC,GAAC;kBAMH,MAAM;kBAQJ,KAAK,CAAE,MAAM,CAAC;6CAQhB,GAAC;8BAQD,MAAM;gBAQJ,MAAM;gBAeP,MAAM,WACH,GAAC,EAAA;EAKvB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.js"],"names":[],"mappings":"AAsCA,iBAAS,IAAI,CAAG,GAAG;IAAG,QAAQ;CAAG;;;;;;;;;;;;;;;;;IA0CzB;;;;;;;;;;;;;;OAcG;2BAPQ,KAAK,+CAAc,KACjB,OAAO,CAAE,UAAU,CAAC;IAajC;;;;;OAKG;4BAFQ,GAAC;IAKZ;;;;OAIG;2BADU,GAAC;IAId;;;;OAIG;oBAFQ,MAAM;IAKjB;;;;OAIG;sBADU,KAAK,CAAE,MAAM,CAAC;IAI3B;;;;;;OAMG;+CAFQ,GAAC;IAKZ;;;;;OAKG;gCAFQ,MAAM;IAKjB;;;;;;;OAOG;oBAJU,MAAM;IAYlB;;;;;;OAMG;kBAHQ,MAAM,WACH,GAAC,EAAA;EAOvB;eAIc,IAAI"}

package/types/methods/hide.d.ts

@@ -1,3 +1,3 @@
-export default hide;
 declare function hide(dependencies: any, state: any): (endSteps?: number | string) => Promise<any>;
+export default hide;
 //# sourceMappingURL=hide.d.ts.map

package/types/methods/hide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hide.d.ts","sourceRoot":"","sources":["../../src/methods/hide.js"],"names":[],"mappings":";AAIA,uDAOuB,WAHZ,MAAM,GAAC,MAGe,kBAmC/B"}
+{"version":3,"file":"hide.d.ts","sourceRoot":"","sources":["../../src/methods/hide.js"],"names":[],"mappings":"AAIA,iBAAS,IAAI,CAAG,YAAY,KAAA,EAAE,KAAK,KAAA,eAIxB,MAAM,GAAC,MAAM,kBAsCtB;eAIa,IAAI"}

package/types/methods/jump.d.ts

@@ -1,5 +1,5 @@
-export default jump;
 declare function jump(state: any, show: any): ({ scene }: {
     scene: string;
 }, ...args?: any[]) => Promise<any>;
+export default jump;
 //# sourceMappingURL=jump.d.ts.map

package/types/methods/jump.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jump.d.ts","sourceRoot":"","sources":["../../src/methods/jump.js"],"names":[],"mappings":";AAAA,0DAKO;IAAwB,KAAK,EAArB,MAAM;CACd,mCAQN"}
+{"version":3,"file":"jump.d.ts","sourceRoot":"","sources":["../../src/methods/jump.js"],"names":[],"mappings":"AAAA,iBAAS,IAAI,CAAG,KAAK,KAAA,EAAE,IAAI,KAAA,eAKpB;IAAwB,KAAK,EAArB,MAAM,CACd;CAAA,mCAQN;eAIc,IAAI"}

package/types/methods/jumpBack.d.ts

@@ -1,5 +1,5 @@
-export default jumpBack;
 declare function jumpBack(state: any, show: any): ({ hops }?: {
-    hops?: number | undefined;
+    hops?: number;
 }, ...args?: any[]) => Promise<any> | undefined;
+export default jumpBack;
 //# sourceMappingURL=jumpBack.d.ts.map

package/types/methods/jumpBack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jumpBack.d.ts","sourceRoot":"","sources":["../../src/methods/jumpBack.js"],"names":[],"mappings":";AAAA,8DAKO;IAAyB,IAAI;CAC7B,sBACU,eAAQ,SAAS,CAWjC"}
+{"version":3,"file":"jumpBack.d.ts","sourceRoot":"","sources":["../../src/methods/jumpBack.js"],"names":[],"mappings":"AAAA,iBAAS,QAAQ,CAAG,KAAK,KAAA,EAAE,IAAI,KAAA,eAKxB;IAAyB,IAAI,AAA7B,CACA,EADQ,MAAM,CACd;CAAA,sBACU,eAAQ,SAAS,CAWjC;eAGc,QAAQ"}

package/types/methods/jumpsReset.d.ts

@@ -1,3 +1,3 @@
-export default jumpsReset;
 declare function jumpsReset(state: any): () => void;
+export default jumpsReset;
 //# sourceMappingURL=jumpsReset.d.ts.map

package/types/methods/jumpsReset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jumpsReset.d.ts","sourceRoot":"","sources":["../../src/methods/jumpsReset.js"],"names":[],"mappings":";AAAA,+CAIiB,IAAI,CAKpB"}
+{"version":3,"file":"jumpsReset.d.ts","sourceRoot":"","sources":["../../src/methods/jumpsReset.js"],"names":[],"mappings":"AAAA,iBAAS,UAAU,CAAG,KAAK,KAAA,SAIV,IAAI,CAKpB;eAIc,UAAU"}

package/types/methods/listShortcuts.d.ts

@@ -1,3 +1,3 @@
-export default listShortcuts;
 declare function listShortcuts(dependencies: any, state: any): (sceneName: string) => (Array<string> | null);
+export default listShortcuts;
 //# sourceMappingURL=listShortcuts.d.ts.map

package/types/methods/listShortcuts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"listShortcuts.d.ts","sourceRoot":"","sources":["../../src/methods/listShortcuts.js"],"names":[],"mappings":";AAEA,gEAOgC,WAHrB,MAG8B,KAF5B,CAAC,KAAK,CAAE,MAAM,CAAC,GAAC,IAAI,CAAC,CAOhC"}
+{"version":3,"file":"listShortcuts.d.ts","sourceRoot":"","sources":["../../src/methods/listShortcuts.js"],"names":[],"mappings":"AAEA,iBAAS,aAAa,CAAG,YAAY,KAAA,EAAE,KAAK,KAAA,eAIjC,MAAM,KACJ,CAAC,KAAK,CAAE,MAAM,CAAC,GAAC,IAAI,CAAC,CAOhC;eAIa,aAAa"}

package/types/methods/setScenes.d.ts

@@ -1,4 +1,3 @@
-export default setScenes;
 export type AskObject = {
     /**
      * - Mark the task as done
@@ -7,35 +6,29 @@ export type AskObject = {
 };
 export type SceneObject = {
     /**
-     * - load interface and prerequisites for the scene;
+     * ({task: AskObject, dependencies: *}): void} show - load interface and prerequisites for the scene;
      */
-    show: (arg0: {
-        task: AskObject;
-        dependencies: any;
-    }) => void;
+    : Function;
     /**
-     * - run after scene is loaded. Optional. Returns true to continue loading, false to cancel;
+     * ():boolean} [afterShow] - run after scene is loaded. Optional. Returns true to continue loading, false to cancel;
      */
-    afterShow?: (() => boolean) | undefined;
+    : Function;
     /**
-     * - Reverse the settings from 'show';
+     * ({task: AskObject, dependencies: *}): void} hide - Reverse the settings from 'show';
      */
-    hide: (arg0: {
-        task: AskObject;
-        dependencies: any;
-    }) => void;
+    : Function;
     /**
-     * - Run before scene is hidden. Optional;
+     * ():void} [beforeHide] - Run before scene is hidden. Optional;
      */
-    beforeHide?: (() => void) | undefined;
+    : Function;
     /**
      * - list of parent scene names.
      */
-    parents?: string[] | undefined;
+    parents?: Array<string>;
     /**
      * - shortcut descriptions
      */
-    "": any;
+    : any;
 };
 export type sceneDescription = {
     /**
@@ -66,4 +59,5 @@ export type sceneDescription = {
  * @property {SceneObject} scene - object should contain 'show' and 'hide' + shortcuts and action functions
  */
 declare function setScenes(dependencies: any, state: any): (list: sceneDescription[]) => void;
+export default setScenes;
 //# sourceMappingURL=setScenes.d.ts.map

package/types/methods/setScenes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setScenes.d.ts","sourceRoot":"","sources":["../../src/methods/setScenes.js"],"names":[],"mappings":";;;;;;;;;;;UASc,CAAS,IAAkC,EAAlC;QAAC,IAAI,EAAE,SAAS,CAAC;QAAC,YAAY,EAAE,GAAC,CAAA;KAAC,KAAG,IAAI;;;;uBACvC,OAAO;;;;UAClB,CAAS,IAAkC,EAAlC;QAAC,IAAI,EAAE,SAAS,CAAC;QAAC,YAAY,EAAE,GAAC,CAAA;KAAC,KAAG,IAAI;;;;wBACvC,IAAI;;;;;;;;QAEf,GAAC;;;;;;UAOD,MAAM;;;;WACN,WAAW;;AAnBzB;;;GAGG;AACH;;;;;;;;GAQG;AAIH;;;;GAIG;AAKH,4DAOgC,MAJhB,gBAAgB,EAII,UAkClC"}
+{"version":3,"file":"setScenes.d.ts","sourceRoot":"","sources":["../../src/methods/setScenes.js"],"names":[],"mappings":"AAIG,YAAkB,SAAS,GAC3B;;;;IAAqB,IAAI,WAC3B;CAAA,CAAA;AAEE,YAAkB,WAAW,GAC7B;;;;IAAmB,WACnB;;;;IAAmB,WACnB;;;;IAAmB,WACnB;;;;IAAmB,WACnB;;;;IAA4B,OAAO,AAAnC,CACA,EADW,KAAK,CAAE,MAAM,CAAC,CACzB;;;;IAAkB,AAAD,EAAN,GAAC,CACd;CAAA,CAAA;AAKE,YAAkB,gBAAgB,GAClC;;;;IAAmB,IAAI,EAAZ,MAAM,CACjB;;;;IAAwB,KAAK,EAAlB,WAAW,CACxB;CAAA,CAAA;AApBD;;;GAGG;AACH;;;;;;;;GAQG;AAIH;;;;GAIG;AAKH,iBAAS,SAAS,CAAG,YAAY,KAAA,EAAE,KAAK,KAAA,UAGxB,gBAAgB,EAAE,UAsChC;eAIa,SAAS"}

package/types/methods/show.d.ts

@@ -1,8 +1,8 @@
-export default show;
 declare function show(dependencies: any, state: any): ({ scene: requestedScene, options }: {
     scene: string;
     options?: {
         ssr: boolean;
-    } | undefined;
+    };
 }, ...args?: any[]) => Promise<any>;
+export default show;
 //# sourceMappingURL=show.d.ts.map

package/types/methods/show.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"show.d.ts","sourceRoot":"","sources":["../../src/methods/show.js"],"names":[],"mappings":";AAIA,2FAKG;IAAwB,KAAK,EAArB,MAAM;IACW,OAAO;aACxB,OAAO;;CACf,mCA4GF"}
+{"version":3,"file":"show.d.ts","sourceRoot":"","sources":["../../src/methods/show.js"],"names":[],"mappings":"AAIA,iBAAS,IAAI,CAAG,YAAY,KAAA,EAAE,KAAK,KAAA,wCAKhC;IAAwB,KAAK,EAArB,MAAM,CACd;IAAyB,OAAO,AAAhC,CAEA,EADA;QAAiC,GAAG,EAA5B,OAAO,CACf;KAAA,CAAA;CAAA,mCAqHF;eAIc,IAAI"}

package/types/setInstruction.d.ts

@@ -1,3 +1,3 @@
-export default setInstruction;
 declare function setInstruction(dependencies: any): (fn: Function, ...args: any[]) => Function;
+export default setInstruction;
 //# sourceMappingURL=setInstruction.d.ts.map

package/types/setInstruction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setInstruction.d.ts","sourceRoot":"","sources":["../src/setInstruction.js"],"names":[],"mappings":";AAEA,qDAQiC,YAAE,EAAE,GAAG,MAHtB,GAAC,EAGyB,cAO1C"}
+{"version":3,"file":"setInstruction.d.ts","sourceRoot":"","sources":["../src/setInstruction.js"],"names":[],"mappings":"AAEA,iBAAS,cAAc,CAAG,YAAY,KAAA,2BAKpB,GAAC,EAAA,cAUjB;eAIa,cAAc"}