@empathyco/x-components 3.0.0-alpha.30 → 3.0.0-alpha.301

package/js/wiring/namespaced-wires.factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"namespaced-wires.factory.js","sources":["../../../src/wiring/namespaced-wires.factory.ts"],"sourcesContent":["import { XModuleName } from '../x-modules/x-modules.types';\nimport {\n  NamespacedWireCommit,\n  NamespacedWireCommitWithoutPayload,\n  NamespacedWireDispatch,\n  NamespacedWireDispatchWithoutPayload\n} from './namespaced-wiring.types';\nimport {\n  wireCommit,\n  wireCommitWithoutPayload,\n  wireDispatch,\n  wireDispatchWithoutPayload\n} from './wires.factory';\nimport { PayloadFactoryData } from './wiring.types';\nimport { getStateAndGettersFromModule } from './wiring.utils';\n\n/**\n * Creates a namespaced {@link (wireCommit:1)} for the module name passed.\n *\n * @param moduleName - The module name for scoping the {@link (wireCommit:1)}.\n * @returns A function which creates a namespaced wire for the {@link (wireCommit:1)}.\n *\n * @public\n */\nexport function namespacedWireCommit<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedWireCommit<ModuleName> {\n  return (mutation: string, payload?: unknown) =>\n    wireCommit(`x/${moduleName}/${mutation}`, getPayload(moduleName, payload));\n}\n\n/**\n * Creates a namespaced {@link wireCommitWithoutPayload} for the module name passed.\n *\n * @param moduleName - The module name for scoping the {@link wireCommitWithoutPayload}.\n * @returns A function which creates a namespaced wire for the {@link wireCommitWithoutPayload}.\n *\n * @public\n */\nexport function namespacedWireCommitWithoutPayload<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedWireCommitWithoutPayload<ModuleName> {\n  return mutation => wireCommitWithoutPayload(`x/${moduleName}/${mutation as string}`);\n}\n\n/**\n * Creates a namespaced {@link (wireDispatch:1)} for the module name passed.\n *\n * @param moduleName - The module name for scoping the {@link (wireDispatch:1)}.\n * @returns A function which creates a namespaced wire for the {@link (wireDispatch:1)}.\n *\n * @public\n */\nexport function namespacedWireDispatch<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedWireDispatch<ModuleName> {\n  return (action: string, payload?: unknown) =>\n    wireDispatch(`x/${moduleName}/${action}`, getPayload(moduleName, payload));\n}\n\n/**\n * Creates a namespaced {@link wireDispatchWithoutPayload} for the module name passed.\n *\n * @param moduleName - The module name for scoping the {@link wireDispatchWithoutPayload}.\n * @returns A function which creates a namespaced wire for the {@link wireDispatchWithoutPayload}.\n *\n * @public\n */\nexport function namespacedWireDispatchWithoutPayload<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedWireDispatchWithoutPayload<ModuleName> {\n  return action => wireDispatchWithoutPayload(`x/${moduleName}/${action as string}`);\n}\n\n/**\n * Decision maker of if the payload is a function which receives the\n * {@link StoreModuleStateAndGetters | module state and getters}, the payload and the metadata,\n * returns the payload for or a static value.\n *\n * @param moduleName - The {@link XModuleName | module name} for scoping the state and getters.\n * @param payload - The payload for the wire which can be a retrieving function or a static value.\n * @returns The function which will retrieve data from the store or the static value.\n *\n * @internal\n */\nfunction getPayload(moduleName: XModuleName, payload: unknown): unknown {\n  return typeof payload === 'function'\n    ? ({ state, getters, eventPayload, metadata }: PayloadFactoryData<XModuleName>) =>\n        payload({\n          ...getStateAndGettersFromModule(state, getters, moduleName),\n          eventPayload,\n          metadata\n        })\n    : payload;\n}\n"],"names":[],"mappings":";;;;AAgBA;;;;;;;;SAQgB,oBAAoB,CAClC,UAAsB;IAEtB,OAAO,UAAC,QAAgB,EAAE,OAAiB;QACzC,OAAA,UAAU,CAAC,OAAK,UAAU,SAAI,QAAU,EAAE,UAAU,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;KAAA,CAAC;AAC/E,CAAC;AAED;;;;;;;;SAQgB,kCAAkC,CAChD,UAAsB;IAEtB,OAAO,UAAA,QAAQ,IAAI,OAAA,wBAAwB,CAAC,OAAK,UAAU,SAAI,QAAoB,CAAC,GAAA,CAAC;AACvF,CAAC;AAED;;;;;;;;SAQgB,sBAAsB,CACpC,UAAsB;IAEtB,OAAO,UAAC,MAAc,EAAE,OAAiB;QACvC,OAAA,YAAY,CAAC,OAAK,UAAU,SAAI,MAAQ,EAAE,UAAU,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;KAAA,CAAC;AAC/E,CAAC;AAED;;;;;;;;SAQgB,oCAAoC,CAClD,UAAsB;IAEtB,OAAO,UAAA,MAAM,IAAI,OAAA,0BAA0B,CAAC,OAAK,UAAU,SAAI,MAAkB,CAAC,GAAA,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;AAWA,SAAS,UAAU,CAAC,UAAuB,EAAE,OAAgB;IAC3D,OAAO,OAAO,OAAO,KAAK,UAAU;UAChC,UAAC,EAA2E;gBAAzE,KAAK,WAAA,EAAE,OAAO,aAAA,EAAE,YAAY,kBAAA,EAAE,QAAQ,cAAA;YACvC,OAAA,OAAO,uBACF,4BAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,KAC3D,YAAY,cAAA,EACZ,QAAQ,UAAA,IACR;SAAA;UACJ,OAAO,CAAC;AACd;;;;"}
+{"version":3,"file":"namespaced-wires.factory.js","sources":["../../../src/wiring/namespaced-wires.factory.ts"],"sourcesContent":["import { XModuleName } from '../x-modules/x-modules.types';\nimport {\n  NamespacedWireCommit,\n  NamespacedWireCommitWithoutPayload,\n  NamespacedWireDispatch,\n  NamespacedWireDispatchWithoutPayload\n} from './namespaced-wiring.types';\nimport {\n  wireCommit,\n  wireCommitWithoutPayload,\n  wireDispatch,\n  wireDispatchWithoutPayload\n} from './wires.factory';\nimport { PayloadFactoryData } from './wiring.types';\nimport { getStateAndGettersFromModule } from './wiring.utils';\n\n/**\n * Creates a namespaced {@link (wireCommit:1)} for the module name passed.\n *\n * @param moduleName - The module name for scoping the {@link (wireCommit:1)}.\n * @returns A function which creates a namespaced wire for the {@link (wireCommit:1)}.\n *\n * @public\n */\nexport function namespacedWireCommit<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedWireCommit<ModuleName> {\n  return (mutation: string, payload?: unknown) =>\n    wireCommit(`x/${moduleName}/${mutation}`, getPayload(moduleName, payload));\n}\n\n/**\n * Creates a namespaced {@link wireCommitWithoutPayload} for the module name passed.\n *\n * @param moduleName - The module name for scoping the {@link wireCommitWithoutPayload}.\n * @returns A function which creates a namespaced wire for the {@link wireCommitWithoutPayload}.\n *\n * @public\n */\nexport function namespacedWireCommitWithoutPayload<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedWireCommitWithoutPayload<ModuleName> {\n  return mutation => wireCommitWithoutPayload(`x/${moduleName}/${mutation as string}`);\n}\n\n/**\n * Creates a namespaced {@link (wireDispatch:1)} for the module name passed.\n *\n * @param moduleName - The module name for scoping the {@link (wireDispatch:1)}.\n * @returns A function which creates a namespaced wire for the {@link (wireDispatch:1)}.\n *\n * @public\n */\nexport function namespacedWireDispatch<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedWireDispatch<ModuleName> {\n  return (action: string, payload?: unknown) =>\n    wireDispatch(`x/${moduleName}/${action}`, getPayload(moduleName, payload));\n}\n\n/**\n * Creates a namespaced {@link wireDispatchWithoutPayload} for the module name passed.\n *\n * @param moduleName - The module name for scoping the {@link wireDispatchWithoutPayload}.\n * @returns A function which creates a namespaced wire for the {@link wireDispatchWithoutPayload}.\n *\n * @public\n */\nexport function namespacedWireDispatchWithoutPayload<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedWireDispatchWithoutPayload<ModuleName> {\n  return action => wireDispatchWithoutPayload(`x/${moduleName}/${action as string}`);\n}\n\n/**\n * Decision maker of if the payload is a function which receives the\n * {@link StoreModuleStateAndGetters | module state and getters}, the payload and the metadata,\n * returns the payload for or a static value.\n *\n * @param moduleName - The {@link XModuleName | module name} for scoping the state and getters.\n * @param payload - The payload for the wire which can be a retrieving function or a static value.\n * @returns The function which will retrieve data from the store or the static value.\n *\n * @internal\n */\nfunction getPayload(moduleName: XModuleName, payload: unknown): unknown {\n  return typeof payload === 'function'\n    ? ({ state, getters, eventPayload, metadata }: PayloadFactoryData<XModuleName>) =>\n        payload({\n          ...getStateAndGettersFromModule(state, getters, moduleName),\n          eventPayload,\n          metadata\n        })\n    : payload;\n}\n"],"names":[],"mappings":";;;AAgBA;;;;;;;AAOG;AACG,SAAU,oBAAoB,CAClC,UAAsB,EAAA;IAEtB,OAAO,CAAC,QAAgB,EAAE,OAAiB,KACzC,UAAU,CAAC,CAAK,EAAA,EAAA,UAAU,IAAI,QAAQ,CAAA,CAAE,EAAE,UAAU,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;AAOG;AACG,SAAU,kCAAkC,CAChD,UAAsB,EAAA;AAEtB,IAAA,OAAO,QAAQ,IAAI,wBAAwB,CAAC,CAAK,EAAA,EAAA,UAAU,CAAI,CAAA,EAAA,QAAkB,CAAE,CAAA,CAAC,CAAC;AACvF,CAAC;AAED;;;;;;;AAOG;AACG,SAAU,sBAAsB,CACpC,UAAsB,EAAA;IAEtB,OAAO,CAAC,MAAc,EAAE,OAAiB,KACvC,YAAY,CAAC,CAAK,EAAA,EAAA,UAAU,IAAI,MAAM,CAAA,CAAE,EAAE,UAAU,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;AAOG;AACG,SAAU,oCAAoC,CAClD,UAAsB,EAAA;AAEtB,IAAA,OAAO,MAAM,IAAI,0BAA0B,CAAC,CAAK,EAAA,EAAA,UAAU,CAAI,CAAA,EAAA,MAAgB,CAAE,CAAA,CAAC,CAAC;AACrF,CAAC;AAED;;;;;;;;;;AAUG;AACH,SAAS,UAAU,CAAC,UAAuB,EAAE,OAAgB,EAAA;IAC3D,OAAO,OAAO,OAAO,KAAK,UAAU;AAClC,UAAE,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAmC,KAC1E,OAAO,CAAC;AACN,YAAA,GAAG,4BAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC;YAC3D,YAAY;YACZ,QAAQ;SACT,CAAC;UACJ,OAAO,CAAC;AACd;;;;"}

package/js/wiring/namespaced-wires.operators.js

@@ -1,5 +1,5 @@
+import { debounce, throttle } from './wires.operators.js';
 import { getStateAndGettersFromModule } from './wiring.utils.js';
-import { throttle, debounce } from './wires.operators.js';
 
 /**
  * Type safe debounce operator which creates a function which can only access the Module of
@@ -40,13 +40,7 @@ function namespacedThrottle(moduleName) {
  * @internal
  */
 function createNamespacedTimeWireOperator(moduleName, timingOperator) {
-    return function (wire, timeRetrieving, raceEvent) {
-        if (raceEvent === void 0) { raceEvent = []; }
-        return timingOperator(wire, function (_a) {
-            var state = _a.state, getters = _a.getters;
-            return timeRetrieving(getStateAndGettersFromModule(state, getters, moduleName));
-        }, raceEvent);
-    };
+    return (wire, timeSelector, options) => timingOperator(wire, ({ state, getters }) => timeSelector(getStateAndGettersFromModule(state, getters, moduleName)), options);
 }
 
 export { namespacedDebounce, namespacedThrottle };

package/js/wiring/namespaced-wires.operators.js.map

@@ -1 +1 @@
-{"version":3,"file":"namespaced-wires.operators.js","sources":["../../../src/wiring/namespaced-wires.operators.ts"],"sourcesContent":["import { XModuleName } from '../x-modules/x-modules.types';\nimport { XEvent } from './events.types';\nimport { NamespacedTimeRetrieving, NamespacedTimeWireOperator } from './namespaced-wiring.types';\nimport { debounce, throttle } from './wires.operators';\nimport { AnyWire } from './wiring.types';\nimport { getStateAndGettersFromModule } from './wiring.utils';\n\n/**\n * Type safe debounce operator which creates a function which can only access the Module of\n * the {@link https://vuex.vuejs.org/ | Vuex} Store passed as parameter.\n *\n * @param moduleName - The {@link XModuleName} to create the operator wire.\n * @returns A function which creates a wire that uses the {@link debounce} wire operator to\n * execute the `wire` after the time has passed without invoking it. This debounce time\n * is given by the execution of the `timeRetrieving` function.\n *\n * @public\n */\nexport function namespacedDebounce<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedTimeWireOperator<ModuleName, AnyWire> {\n  return createNamespacedTimeWireOperator(moduleName, debounce);\n}\n\n/**\n * Type safe throttle operator which creates a function which can only access the Module of\n * the {@link https://vuex.vuejs.org/ | Vuex} Store passed as parameter.\n *\n * @param moduleName - The {@link XModuleName} to create the operator wire.\n * @returns A function which creates a wire that uses the {@link throttle} wire operator to\n * execute the `wire` once every couple of milliseconds. This throttle time is given by\n * the execution of the `timeRetrieving` function.\n *\n * @public\n */\nexport function namespacedThrottle<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedTimeWireOperator<ModuleName, AnyWire> {\n  return createNamespacedTimeWireOperator(moduleName, throttle);\n}\n\n/**\n * Creates a function which creates a namespaced wire that uses the {@link debounce} or\n * {@link throttle} time wire operator.\n *\n * @param moduleName - The {@link XModuleName} to create the operator wire.\n * @param timingOperator - The time wire operator {@link debounce} or {@link throttle}.\n * @returns A function which creates a namespaced time wire operator.\n *\n * @internal\n */\nfunction createNamespacedTimeWireOperator<ModuleName extends XModuleName>(\n  moduleName: ModuleName,\n  timingOperator: typeof throttle | typeof debounce\n): NamespacedTimeWireOperator<ModuleName, AnyWire> {\n  return (\n    wire: AnyWire,\n    timeRetrieving: NamespacedTimeRetrieving<ModuleName>,\n    raceEvent: XEvent | XEvent[] = []\n  ) =>\n    timingOperator(\n      wire,\n      ({ state, getters }) =>\n        timeRetrieving(getStateAndGettersFromModule(state, getters, moduleName)),\n      raceEvent\n    );\n}\n"],"names":[],"mappings":";;;AAOA;;;;;;;;;;;SAWgB,kBAAkB,CAChC,UAAsB;IAEtB,OAAO,gCAAgC,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;SAWgB,kBAAkB,CAChC,UAAsB;IAEtB,OAAO,gCAAgC,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;AAUA,SAAS,gCAAgC,CACvC,UAAsB,EACtB,cAAiD;IAEjD,OAAO,UACL,IAAa,EACb,cAAoD,EACpD,SAAiC;QAAjC,0BAAA,EAAA,cAAiC;QAEjC,OAAA,cAAc,CACZ,IAAI,EACJ,UAAC,EAAkB;gBAAhB,KAAK,WAAA,EAAE,OAAO,aAAA;YACf,OAAA,cAAc,CAAC,4BAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;SAAA,EAC1E,SAAS,CACV;KAAA,CAAC;AACN;;;;"}
+{"version":3,"file":"namespaced-wires.operators.js","sources":["../../../src/wiring/namespaced-wires.operators.ts"],"sourcesContent":["import { XModuleName } from '../x-modules/x-modules.types';\nimport { NamespacedTimeWireOperator } from './namespaced-wiring.types';\nimport { debounce, throttle } from './wires.operators';\nimport { getStateAndGettersFromModule } from './wiring.utils';\n\n/**\n * Type safe debounce operator which creates a function which can only access the Module of\n * the {@link https://vuex.vuejs.org/ | Vuex} Store passed as parameter.\n *\n * @param moduleName - The {@link XModuleName} to create the operator wire.\n * @returns A function which creates a wire that uses the {@link debounce} wire operator to\n * execute the `wire` after the time has passed without invoking it. This debounce time\n * is given by the execution of the `timeRetrieving` function.\n *\n * @public\n */\nexport function namespacedDebounce<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedTimeWireOperator<ModuleName> {\n  return createNamespacedTimeWireOperator(moduleName, debounce);\n}\n\n/**\n * Type safe throttle operator which creates a function which can only access the Module of\n * the {@link https://vuex.vuejs.org/ | Vuex} Store passed as parameter.\n *\n * @param moduleName - The {@link XModuleName} to create the operator wire.\n * @returns A function which creates a wire that uses the {@link throttle} wire operator to\n * execute the `wire` once every couple of milliseconds. This throttle time is given by\n * the execution of the `timeRetrieving` function.\n *\n * @public\n */\nexport function namespacedThrottle<ModuleName extends XModuleName>(\n  moduleName: ModuleName\n): NamespacedTimeWireOperator<ModuleName> {\n  return createNamespacedTimeWireOperator(moduleName, throttle);\n}\n\n/**\n * Creates a function which creates a namespaced wire that uses the {@link debounce} or\n * {@link throttle} time wire operator.\n *\n * @param moduleName - The {@link XModuleName} to create the operator wire.\n * @param timingOperator - The time wire operator {@link debounce} or {@link throttle}.\n * @returns A function which creates a namespaced time wire operator.\n *\n * @internal\n */\nfunction createNamespacedTimeWireOperator<ModuleName extends XModuleName>(\n  moduleName: ModuleName,\n  timingOperator: typeof throttle | typeof debounce\n): NamespacedTimeWireOperator<ModuleName> {\n  return (wire, timeSelector, options) =>\n    timingOperator(\n      wire,\n      ({ state, getters }) =>\n        timeSelector(getStateAndGettersFromModule(state, getters, moduleName)),\n      options\n    );\n}\n"],"names":[],"mappings":";;;AAKA;;;;;;;;;;AAUG;AACG,SAAU,kBAAkB,CAChC,UAAsB,EAAA;AAEtB,IAAA,OAAO,gCAAgC,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;AAUG;AACG,SAAU,kBAAkB,CAChC,UAAsB,EAAA;AAEtB,IAAA,OAAO,gCAAgC,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;AASG;AACH,SAAS,gCAAgC,CACvC,UAAsB,EACtB,cAAiD,EAAA;AAEjD,IAAA,OAAO,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,KACjC,cAAc,CACZ,IAAI,EACJ,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KACjB,YAAY,CAAC,4BAA4B,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC,EACxE,OAAO,CACR,CAAC;AACN;;;;"}

package/js/wiring/wires-operators.utils.js

@@ -0,0 +1,54 @@
+import { timer, race, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+
+/**
+ * Creates the observable for the events that will be racing the wire's execution.
+ *
+ * @param events - The events to merge its observables.
+ * @param on - The on function of the {@link XBus} where the events will run.
+ * @returns The observable for the racing events.
+ * @internal
+ */
+function mergeEvents(events, on) {
+    const subject = new Subject();
+    const eventsList = Array.isArray(events) ? events : [events];
+    /* Can't use RxJS `merge` function, as it immediately emits previously emitted values to new
+     subscriptions due to the `ReplaySubject` of the bus. With this Subject we are still receiving
+     those values immediately on subscription, but as there are no subscribers before the `return`
+     happens we are fine. */
+    eventsList.forEach(raceEvent => on(raceEvent).subscribe(() => subject.next()));
+    return subject;
+}
+/**
+ * Checks how to retrieve the timeout time, retrieves it and returns it in ms.
+ *
+ * @param timeInMs - Time for the timeout in ms.
+ * @param store - The store of the wire that will be timed out.
+ * @returns The time in ms for the timeout.
+ * @internal
+ */
+function normalizeTime(timeInMs, store) {
+    return typeof timeInMs === 'function' ? timeInMs(store) : timeInMs;
+}
+/**
+ * Creates a timer observable that depending on the provided options might be aborted or forced.
+ *
+ * @param durationInMs - The duration in ms for the timer.
+ * @param options - Options to configure the timer, like an events to force it or cancel it.
+ * @param on - The {@link XBus.on} method.
+ * @returns A timer observable that can be aborted or forced depending on the provided options.
+ * @internal
+ */
+function createTimer(durationInMs, { cancelOn, forceOn }, on) {
+    let timerObservable = timer(durationInMs);
+    if (forceOn) {
+        timerObservable = race(timerObservable, mergeEvents(forceOn, on));
+    }
+    if (cancelOn) {
+        timerObservable = timerObservable.pipe(takeUntil(mergeEvents(cancelOn, on)));
+    }
+    return timerObservable;
+}
+
+export { createTimer, mergeEvents, normalizeTime };
+//# sourceMappingURL=wires-operators.utils.js.map

package/js/wiring/wires-operators.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wires-operators.utils.js","sources":["../../../src/wiring/wires-operators.utils.ts"],"sourcesContent":["import { Subject, Observable, timer, race } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { Store } from 'vuex';\nimport { XBus } from '../plugins/x-bus.types';\nimport { RootXStoreState } from '../store/store.types';\nimport { MaybeArray } from '../utils/types';\nimport { XEvent } from './events.types';\nimport { TimedWireOperatorOptions, TimeSelector } from './wiring.types';\n\n/**\n * Creates the observable for the events that will be racing the wire's execution.\n *\n * @param events - The events to merge its observables.\n * @param on - The on function of the {@link XBus} where the events will run.\n * @returns The observable for the racing events.\n * @internal\n */\nexport function mergeEvents(events: MaybeArray<XEvent>, on: XBus['on']): Observable<void> {\n  const subject = new Subject<void>();\n  const eventsList = Array.isArray(events) ? events : [events];\n\n  /* Can't use RxJS `merge` function, as it immediately emits previously emitted values to new\n   subscriptions due to the `ReplaySubject` of the bus. With this Subject we are still receiving\n   those values immediately on subscription, but as there are no subscribers before the `return`\n   happens we are fine. */\n  eventsList.forEach(raceEvent => on(raceEvent).subscribe(() => subject.next()));\n  return subject;\n}\n\n/**\n * Checks how to retrieve the timeout time, retrieves it and returns it in ms.\n *\n * @param timeInMs - Time for the timeout in ms.\n * @param store - The store of the wire that will be timed out.\n * @returns The time in ms for the timeout.\n * @internal\n */\nexport function normalizeTime(\n  timeInMs: TimeSelector | number,\n  store: Store<RootXStoreState>\n): number {\n  return typeof timeInMs === 'function' ? timeInMs(store) : timeInMs;\n}\n\n/**\n * Creates a timer observable that depending on the provided options might be aborted or forced.\n *\n * @param durationInMs - The duration in ms for the timer.\n * @param options - Options to configure the timer, like an events to force it or cancel it.\n * @param on - The {@link XBus.on} method.\n * @returns A timer observable that can be aborted or forced depending on the provided options.\n * @internal\n */\nexport function createTimer(\n  durationInMs: number,\n  { cancelOn, forceOn }: TimedWireOperatorOptions,\n  on: XBus['on']\n): Observable<unknown> {\n  let timerObservable: Observable<unknown> = timer(durationInMs);\n  if (forceOn) {\n    timerObservable = race(timerObservable, mergeEvents(forceOn, on));\n  }\n\n  if (cancelOn) {\n    timerObservable = timerObservable.pipe(takeUntil(mergeEvents(cancelOn, on)));\n  }\n\n  return timerObservable;\n}\n"],"names":[],"mappings":";;;AASA;;;;;;;AAOG;AACa,SAAA,WAAW,CAAC,MAA0B,EAAE,EAAc,EAAA;AACpE,IAAA,MAAM,OAAO,GAAG,IAAI,OAAO,EAAQ,CAAC;AACpC,IAAA,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC;AAE7D;;;AAGwB;IACxB,UAAU,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,MAAM,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAC/E,IAAA,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;AAOG;AACa,SAAA,aAAa,CAC3B,QAA+B,EAC/B,KAA6B,EAAA;AAE7B,IAAA,OAAO,OAAO,QAAQ,KAAK,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC;AACrE,CAAC;AAED;;;;;;;;AAQG;AACG,SAAU,WAAW,CACzB,YAAoB,EACpB,EAAE,QAAQ,EAAE,OAAO,EAA4B,EAC/C,EAAc,EAAA;AAEd,IAAA,IAAI,eAAe,GAAwB,KAAK,CAAC,YAAY,CAAC,CAAC;AAC/D,IAAA,IAAI,OAAO,EAAE;AACX,QAAA,eAAe,GAAG,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AACnE,KAAA;AAED,IAAA,IAAI,QAAQ,EAAE;AACZ,QAAA,eAAe,GAAG,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9E,KAAA;AAED,IAAA,OAAO,eAAe,CAAC;AACzB;;;;"}

package/js/wiring/wires.factory.js

@@ -1,5 +1,3 @@
-import { __assign } from 'tslib';
-
 /**
  * Creates a wire that executes the function passed. This function will receive a
  * {@link WireParams} object.
@@ -9,18 +7,13 @@ import { __assign } from 'tslib';
  * @public
  */
 function createWireFromFunction(fn) {
-    return function (observable, store) {
-        return observable.subscribe(function (_a) {
-            var metadata = _a.metadata, eventPayload = _a.eventPayload;
-            fn({ eventPayload: eventPayload, store: store, metadata: metadata });
-        });
-    };
+    return (observable, store) => observable.subscribe(({ metadata, eventPayload }) => {
+        fn({ eventPayload, store, metadata });
+    });
 }
 // eslint-disable-next-line jsdoc/require-jsdoc
 function wireCommit(mutation, payload) {
-    return function (observable, store) {
-        return observable.subscribe(createSubscriptionCallback(store, 'commit', mutation, payload));
-    };
+    return (observable, store) => observable.subscribe(createSubscriptionCallback(store, 'commit', mutation, payload));
 }
 /**
  * Creates a wire that commits a mutation to the store, but without any payload. This wire can
@@ -31,13 +24,11 @@ function wireCommit(mutation, payload) {
  * @public
  */
 function wireCommitWithoutPayload(mutation) {
-    return function (observable, store) { return observable.subscribe(function () { return store.commit(mutation); }); };
+    return (observable, store) => observable.subscribe(() => store.commit(mutation));
 }
 // eslint-disable-next-line jsdoc/require-jsdoc
 function wireDispatch(action, payload) {
-    return function (observable, store) {
-        return observable.subscribe(createSubscriptionCallback(store, 'dispatch', action, payload));
-    };
+    return (observable, store) => observable.subscribe(createSubscriptionCallback(store, 'dispatch', action, payload));
 }
 /**
  * Creates a wire that dispatches an action to the store, but without any payload. This wire can
@@ -48,7 +39,7 @@ function wireDispatch(action, payload) {
  * @public
  */
 function wireDispatchWithoutPayload(action) {
-    return function (observable, store) { return observable.subscribe(function () { return store.dispatch(action); }); };
+    return (observable, store) => observable.subscribe(() => store.dispatch(action));
 }
 /**
  * Creates a wires factory that can create wires that will invoke the service methods.
@@ -58,12 +49,10 @@ function wireDispatchWithoutPayload(action) {
  * @public
  */
 function wireService(service) {
-    return function (method, payload) {
-        return function (observable) {
-            return observable.subscribe(payload !== undefined
-                ? function () { return service[method](payload); }
-                : function (observablePayload) { return service[method](observablePayload.eventPayload); });
-        };
+    return (method, payload) => {
+        return observable => observable.subscribe(payload !== undefined
+            ? () => service[method](payload)
+            : observablePayload => service[method](observablePayload.eventPayload));
     };
 }
 /**
@@ -75,8 +64,8 @@ function wireService(service) {
  * @public
  */
 function wireServiceWithoutPayload(service) {
-    return function (method) {
-        return function (observable) { return observable.subscribe(function () { return service[method](); }); };
+    return method => {
+        return observable => observable.subscribe(() => service[method]());
     };
 }
 /**
@@ -94,16 +83,20 @@ function wireServiceWithoutPayload(service) {
  * @internal
  */
 function createSubscriptionCallback(store, commitOrDispatch, mutationOrAction, payload) {
-    var storeExecutor = store[commitOrDispatch];
+    const storeExecutor = store[commitOrDispatch];
     return typeof payload === 'function'
-        ? function (wirePayload) {
-            return storeExecutor(mutationOrAction, payload(__assign({ state: store.state, getters: store.getters }, wirePayload)));
+        ? wirePayload => {
+            return storeExecutor(mutationOrAction, payload({
+                state: store.state,
+                getters: store.getters,
+                ...wirePayload
+            }));
         }
         : payload !== undefined
-            ? function () {
+            ? () => {
                 storeExecutor(mutationOrAction, payload);
             }
-            : function (observableValue) {
+            : observableValue => {
                 storeExecutor(mutationOrAction, observableValue.eventPayload);
             };
 }

package/js/wiring/wires.factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"wires.factory.js","sources":["../../../src/wiring/wires.factory.ts"],"sourcesContent":["import { Store } from 'vuex';\nimport { RootXStoreState } from '../store/store.types';\nimport {\n  AnyWire,\n  PayloadFactoryData,\n  Wire,\n  WireParams,\n  WirePayload,\n  WireService,\n  WireServiceWithoutPayload\n} from './wiring.types';\n\n/**\n * Creates a wire that executes the function passed. This function will receive a\n * {@link WireParams} object.\n *\n * @param fn - The function to execute whenever a new value is emitted to the observable.\n * @returns The Wire function.\n * @public\n */\nexport function createWireFromFunction<Payload>(\n  fn: (parameters: WireParams<Payload>) => void\n): Wire<Payload> {\n  return (observable, store) =>\n    observable.subscribe(({ metadata, eventPayload }) => {\n      fn({ eventPayload, store, metadata });\n    });\n}\n\n/**\n * Creates a wire that commits a mutation to the store. This wire receives a function. This function\n * is used to get the actual payload value passed to mutation.\n * This wire can be used in every event, as it does not have a payload type associated.\n *\n * @param mutation - The full mutation path to commit. I.e. `x/searchBox/setQuery`.\n * @param payloadFactory - A function that receives a {@link PayloadFactoryData | object}\n * with the Store state, getters, payload and metadata as parameter.\n * @returns A {@link AnyWire} wire that commits the mutation with the payload returned by the\n * payloadFactory.\n * @public\n */\nexport function wireCommit<Payload>(\n  mutation: string,\n  payloadFactory: (params: PayloadFactoryData<Payload>) => any\n): AnyWire;\n/**\n * Creates a wire that commits a mutation to the store. This wire can receive any value as payload.\n * This wire can be used in every event, as it does not have a payload type associated.\n *\n * @param mutation - The full mutation path to commit. I.e. `x/searchBox/setQuery`.\n * @param staticPayload - A static payload to pass to the mutation.\n * @returns {@link AnyWire} A wire that commits the mutation with the staticPayload payload.\n * @public\n */\nexport function wireCommit(mutation: string, staticPayload: any): AnyWire;\n/**\n * Creates a wire that commits a mutation to the store. This wire will commit to the store the\n * payload that it receives in the observable.\n *\n * @param mutation - The full mutation path to commit. I.e. `x/searchBox/setQuery`.\n * @typeParam Payload - The type of the payload that this wire will receive\n * @returns {@link Wire} A wire that commits the mutation with the payload that it receives\n * in the observable.\n * @public\n */\nexport function wireCommit<Payload>(mutation: string): Wire<Payload>;\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function wireCommit<Payload>(mutation: string, payload?: Payload): Wire<Payload> {\n  return (observable, store) =>\n    observable.subscribe(createSubscriptionCallback(store, 'commit', mutation, payload));\n}\n\n/**\n * Creates a wire that commits a mutation to the store, but without any payload. This wire can\n * be used in every event, as it does not have a payload type associated.\n *\n * @param mutation - The full mutation path to commit. I.e. `x/searchBox/setQuery`.\n * @returns {@link AnyWire} A wire that commits the mutation without any payload.\n * @public\n */\nexport function wireCommitWithoutPayload(mutation: string): AnyWire {\n  return (observable, store) => observable.subscribe(() => store.commit(mutation));\n}\n\n/**\n * Creates a wire that dispatch an action to the store. This wire receives a function. This function\n * is used to get the actual payload value passed to action.\n * This wire can be used in every event, as it does not have a payload type associated.\n *\n * @param action - The full action path to dispatch. I.e. `x/querySuggestions/fetchSuggestions`.\n * @param payloadFactory - A function that receives a {@link PayloadFactoryData | object}\n * with the Store state, getters, payload and metadata as parameter.\n * @returns A {@link AnyWire} wire that dispatches the action with the payload returned by the\n * payloadFactory.\n * @public\n */\nexport function wireDispatch<Payload>(\n  action: string,\n  payloadFactory: (params: PayloadFactoryData<Payload>) => any\n): AnyWire;\n/**\n * Creates a wire that dispatches an action to the store. This wire can be used in every event,\n * as it does not have a payload type associated.\n *\n * @param action - The full action path to dispatch. I.e. `x/querySuggestions/fetchSuggestions`.\n * @param staticPayload - A static payload to pass to the action which will be dispatched.\n * @returns {@link AnyWire} A wire that dispatches the action with the staticPayload payload.\n * @public\n */\nexport function wireDispatch(action: string, staticPayload: any): AnyWire;\n/**\n * Creates a wire that dispatches an action to the store. This wire will pass the payload\n * received in the observable to the action.\n *\n * @param action - The full action path to dispatch. I.e. `x/querySuggestions/fetchSuggestions`.\n * @typeParam Payload - The type of the payload that this wire will receive\n * @returns {@link Wire} A wire that dispatches the action with the payload that it receives\n * in the observable.\n * @public\n */\nexport function wireDispatch<Payload>(action: string): Wire<Payload>;\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function wireDispatch<Payload>(action: string, payload?: Payload): Wire<Payload> {\n  return (observable, store) =>\n    observable.subscribe(createSubscriptionCallback(store, 'dispatch', action, payload));\n}\n\n/**\n * Creates a wire that dispatches an action to the store, but without any payload. This wire can\n * be used in every event, as it does not have a payload type associated.\n *\n * @param action - The full action path to dispatch. I.e. `x/querySuggestions/fetchSuggestions`.\n * @returns {@link AnyWire} A wire that dispatches the action without any payload.\n * @public\n */\nexport function wireDispatchWithoutPayload(action: string): AnyWire {\n  return (observable, store) => observable.subscribe(() => store.dispatch(action));\n}\n\n/**\n * Creates a wires factory that can create wires that will invoke the service methods.\n *\n * @param service - The service to invoke its methods.\n * @returns A factory to create wires that invoke the service methods.\n * @public\n */\nexport function wireService<SomeService>(service: SomeService): WireService<SomeService> {\n  return (method, payload?) => {\n    return observable =>\n      observable.subscribe(\n        payload !== undefined\n          ? () => service[method](payload)\n          : observablePayload => service[method](observablePayload.eventPayload)\n      );\n  };\n}\n\n/**\n * Creates a wires factory that can create wires that will invoke the service methods but\n * without payload.\n *\n * @param service - The service to invoke its methods.\n * @returns A factory to create wires that invoke the service methods without payload.\n * @public\n */\nexport function wireServiceWithoutPayload<SomeService>(\n  service: SomeService\n): WireServiceWithoutPayload<SomeService> {\n  return method => {\n    return observable => observable.subscribe(() => service[method]());\n  };\n}\n\n/**\n * Creates the callback function for the {@link wireCommit} and {@link wireDispatch}\n * subscriptions. It can be based on the payload as function which retrieves the observable\n * payload from the store, a static payload or the event value from the observable.\n *\n * @param store - The {@link RootXStoreState} store.\n * @param commitOrDispatch - The executor over store. It can be `commit` or `dispatch`.\n * @param mutationOrAction - The mutation or action to commit or dispatch respectively.\n * @param payload - The payload for the store executor. It can be a function which retrieves the\n * payload from the store, a static payload or the event value from the observable.\n * @typeParam Payload - The type of the payload to get the observable event value type.\n * @returns A function to commit or dispatch a payload value over store.\n * @internal\n */\nfunction createSubscriptionCallback<Payload>(\n  store: Store<RootXStoreState>,\n  commitOrDispatch: 'commit' | 'dispatch',\n  mutationOrAction: string,\n  payload?: Payload\n): (observableValue: WirePayload<Payload>) => void {\n  const storeExecutor = store[commitOrDispatch];\n  return typeof payload === 'function'\n    ? wirePayload => {\n        return storeExecutor(\n          mutationOrAction,\n          payload({\n            state: store.state,\n            getters: store.getters,\n            ...wirePayload\n          })\n        );\n      }\n    : payload !== undefined\n    ? () => {\n        storeExecutor(mutationOrAction, payload);\n      }\n    : observableValue => {\n        storeExecutor(mutationOrAction, observableValue.eventPayload);\n      };\n}\n"],"names":[],"mappings":";;AAYA;;;;;;;;SAQgB,sBAAsB,CACpC,EAA6C;IAE7C,OAAO,UAAC,UAAU,EAAE,KAAK;QACvB,OAAA,UAAU,CAAC,SAAS,CAAC,UAAC,EAA0B;gBAAxB,QAAQ,cAAA,EAAE,YAAY,kBAAA;YAC5C,EAAE,CAAC,EAAE,YAAY,cAAA,EAAE,KAAK,OAAA,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC;SACvC,CAAC;KAAA,CAAC;AACP,CAAC;AAuCD;SACgB,UAAU,CAAU,QAAgB,EAAE,OAAiB;IACrE,OAAO,UAAC,UAAU,EAAE,KAAK;QACvB,OAAA,UAAU,CAAC,SAAS,CAAC,0BAA0B,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;KAAA,CAAC;AACzF,CAAC;AAED;;;;;;;;SAQgB,wBAAwB,CAAC,QAAgB;IACvD,OAAO,UAAC,UAAU,EAAE,KAAK,IAAK,OAAA,UAAU,CAAC,SAAS,CAAC,cAAM,OAAA,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAA,CAAC,GAAA,CAAC;AACnF,CAAC;AAuCD;SACgB,YAAY,CAAU,MAAc,EAAE,OAAiB;IACrE,OAAO,UAAC,UAAU,EAAE,KAAK;QACvB,OAAA,UAAU,CAAC,SAAS,CAAC,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;KAAA,CAAC;AACzF,CAAC;AAED;;;;;;;;SAQgB,0BAA0B,CAAC,MAAc;IACvD,OAAO,UAAC,UAAU,EAAE,KAAK,IAAK,OAAA,UAAU,CAAC,SAAS,CAAC,cAAM,OAAA,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAA,CAAC,GAAA,CAAC;AACnF,CAAC;AAED;;;;;;;SAOgB,WAAW,CAAc,OAAoB;IAC3D,OAAO,UAAC,MAAM,EAAE,OAAQ;QACtB,OAAO,UAAA,UAAU;YACf,OAAA,UAAU,CAAC,SAAS,CAClB,OAAO,KAAK,SAAS;kBACjB,cAAM,OAAA,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,GAAA;kBAC9B,UAAA,iBAAiB,IAAI,OAAA,OAAO,CAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC,YAAY,CAAC,GAAA,CACzE;SAAA,CAAC;KACL,CAAC;AACJ,CAAC;AAED;;;;;;;;SAQgB,yBAAyB,CACvC,OAAoB;IAEpB,OAAO,UAAA,MAAM;QACX,OAAO,UAAA,UAAU,IAAI,OAAA,UAAU,CAAC,SAAS,CAAC,cAAM,OAAA,OAAO,CAAC,MAAM,CAAC,EAAE,GAAA,CAAC,GAAA,CAAC;KACpE,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;AAcA,SAAS,0BAA0B,CACjC,KAA6B,EAC7B,gBAAuC,EACvC,gBAAwB,EACxB,OAAiB;IAEjB,IAAM,aAAa,GAAG,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAC9C,OAAO,OAAO,OAAO,KAAK,UAAU;UAChC,UAAA,WAAW;YACT,OAAO,aAAa,CAClB,gBAAgB,EAChB,OAAO,YACL,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,OAAO,EAAE,KAAK,CAAC,OAAO,IACnB,WAAW,EACd,CACH,CAAC;SACH;UACD,OAAO,KAAK,SAAS;cACrB;gBACE,aAAa,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;aAC1C;cACD,UAAA,eAAe;gBACb,aAAa,CAAC,gBAAgB,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC;aAC/D,CAAC;AACR;;;;"}
+{"version":3,"file":"wires.factory.js","sources":["../../../src/wiring/wires.factory.ts"],"sourcesContent":["import { Store } from 'vuex';\nimport { RootXStoreState } from '../store/store.types';\nimport { MonadicFunction, NiladicFunction, SubObject } from '../utils/index';\nimport {\n  AnyWire,\n  PayloadFactoryData,\n  Wire,\n  WireParams,\n  WirePayload,\n  WireService,\n  WireServiceWithoutPayload\n} from './wiring.types';\n\n/**\n * Creates a wire that executes the function passed. This function will receive a\n * {@link WireParams} object.\n *\n * @param fn - The function to execute whenever a new value is emitted to the observable.\n * @returns The Wire function.\n * @public\n */\nexport function createWireFromFunction<Payload>(\n  fn: (parameters: WireParams<Payload>) => void\n): Wire<Payload> {\n  return (observable, store) =>\n    observable.subscribe(({ metadata, eventPayload }) => {\n      fn({ eventPayload, store, metadata });\n    });\n}\n\n/**\n * Creates a wire that commits a mutation to the store. This wire receives a function. This function\n * is used to get the actual payload value passed to mutation.\n * This wire can be used in every event, as it does not have a payload type associated.\n *\n * @param mutation - The full mutation path to commit. I.e. `x/searchBox/setQuery`.\n * @param payloadFactory - A function that receives a {@link PayloadFactoryData | object}\n * with the Store state, getters, payload and metadata as parameter.\n * @returns A {@link AnyWire} wire that commits the mutation with the payload returned by the\n * payloadFactory.\n * @public\n */\nexport function wireCommit<Payload>(\n  mutation: string,\n  payloadFactory: (params: PayloadFactoryData<Payload>) => any\n): AnyWire;\n/**\n * Creates a wire that commits a mutation to the store. This wire can receive any value as payload.\n * This wire can be used in every event, as it does not have a payload type associated.\n *\n * @param mutation - The full mutation path to commit. I.e. `x/searchBox/setQuery`.\n * @param staticPayload - A static payload to pass to the mutation.\n * @returns {@link AnyWire} A wire that commits the mutation with the staticPayload payload.\n * @public\n */\nexport function wireCommit(mutation: string, staticPayload: any): AnyWire;\n/**\n * Creates a wire that commits a mutation to the store. This wire will commit to the store the\n * payload that it receives in the observable.\n *\n * @param mutation - The full mutation path to commit. I.e. `x/searchBox/setQuery`.\n * @typeParam Payload - The type of the payload that this wire will receive\n * @returns {@link Wire} A wire that commits the mutation with the payload that it receives\n * in the observable.\n * @public\n */\nexport function wireCommit<Payload>(mutation: string): Wire<Payload>;\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function wireCommit<Payload>(mutation: string, payload?: Payload): Wire<Payload> {\n  return (observable, store) =>\n    observable.subscribe(createSubscriptionCallback(store, 'commit', mutation, payload));\n}\n\n/**\n * Creates a wire that commits a mutation to the store, but without any payload. This wire can\n * be used in every event, as it does not have a payload type associated.\n *\n * @param mutation - The full mutation path to commit. I.e. `x/searchBox/setQuery`.\n * @returns {@link AnyWire} A wire that commits the mutation without any payload.\n * @public\n */\nexport function wireCommitWithoutPayload(mutation: string): AnyWire {\n  return (observable, store) => observable.subscribe(() => store.commit(mutation));\n}\n\n/**\n * Creates a wire that dispatch an action to the store. This wire receives a function. This function\n * is used to get the actual payload value passed to action.\n * This wire can be used in every event, as it does not have a payload type associated.\n *\n * @param action - The full action path to dispatch. I.e. `x/querySuggestions/fetchSuggestions`.\n * @param payloadFactory - A function that receives a {@link PayloadFactoryData | object}\n * with the Store state, getters, payload and metadata as parameter.\n * @returns A {@link AnyWire} wire that dispatches the action with the payload returned by the\n * payloadFactory.\n * @public\n */\nexport function wireDispatch<Payload>(\n  action: string,\n  payloadFactory: (params: PayloadFactoryData<Payload>) => any\n): AnyWire;\n/**\n * Creates a wire that dispatches an action to the store. This wire can be used in every event,\n * as it does not have a payload type associated.\n *\n * @param action - The full action path to dispatch. I.e. `x/querySuggestions/fetchSuggestions`.\n * @param staticPayload - A static payload to pass to the action which will be dispatched.\n * @returns {@link AnyWire} A wire that dispatches the action with the staticPayload payload.\n * @public\n */\nexport function wireDispatch(action: string, staticPayload: any): AnyWire;\n/**\n * Creates a wire that dispatches an action to the store. This wire will pass the payload\n * received in the observable to the action.\n *\n * @param action - The full action path to dispatch. I.e. `x/querySuggestions/fetchSuggestions`.\n * @typeParam Payload - The type of the payload that this wire will receive\n * @returns {@link Wire} A wire that dispatches the action with the payload that it receives\n * in the observable.\n * @public\n */\nexport function wireDispatch<Payload>(action: string): Wire<Payload>;\n// eslint-disable-next-line jsdoc/require-jsdoc\nexport function wireDispatch<Payload>(action: string, payload?: Payload): Wire<Payload> {\n  return (observable, store) =>\n    observable.subscribe(createSubscriptionCallback(store, 'dispatch', action, payload));\n}\n\n/**\n * Creates a wire that dispatches an action to the store, but without any payload. This wire can\n * be used in every event, as it does not have a payload type associated.\n *\n * @param action - The full action path to dispatch. I.e. `x/querySuggestions/fetchSuggestions`.\n * @returns {@link AnyWire} A wire that dispatches the action without any payload.\n * @public\n */\nexport function wireDispatchWithoutPayload(action: string): AnyWire {\n  return (observable, store) => observable.subscribe(() => store.dispatch(action));\n}\n\n/**\n * Creates a wires factory that can create wires that will invoke the service methods.\n *\n * @param service - The service to invoke its methods.\n * @returns A factory to create wires that invoke the service methods.\n * @public\n */\nexport function wireService<SomeService>(\n  service: SomeService & SubObject<SomeService, MonadicFunction>\n): WireService<SubObject<SomeService, MonadicFunction>> {\n  return (method, payload?) => {\n    return observable =>\n      observable.subscribe(\n        payload !== undefined\n          ? () => service[method](payload)\n          : observablePayload => service[method](observablePayload.eventPayload)\n      );\n  };\n}\n\n/**\n * Creates a wires factory that can create wires that will invoke the service methods but\n * without payload.\n *\n * @param service - The service to invoke its methods.\n * @returns A factory to create wires that invoke the service methods without payload.\n * @public\n */\nexport function wireServiceWithoutPayload<SomeService>(\n  service: SomeService & SubObject<SomeService, NiladicFunction>\n): WireServiceWithoutPayload<SubObject<SomeService, NiladicFunction>> {\n  return method => {\n    return observable => observable.subscribe(() => service[method]());\n  };\n}\n\n/**\n * Creates the callback function for the {@link wireCommit} and {@link wireDispatch}\n * subscriptions. It can be based on the payload as function which retrieves the observable\n * payload from the store, a static payload or the event value from the observable.\n *\n * @param store - The {@link RootXStoreState} store.\n * @param commitOrDispatch - The executor over store. It can be `commit` or `dispatch`.\n * @param mutationOrAction - The mutation or action to commit or dispatch respectively.\n * @param payload - The payload for the store executor. It can be a function which retrieves the\n * payload from the store, a static payload or the event value from the observable.\n * @typeParam Payload - The type of the payload to get the observable event value type.\n * @returns A function to commit or dispatch a payload value over store.\n * @internal\n */\nfunction createSubscriptionCallback<Payload>(\n  store: Store<RootXStoreState>,\n  commitOrDispatch: 'commit' | 'dispatch',\n  mutationOrAction: string,\n  payload?: Payload\n): (observableValue: WirePayload<Payload>) => void {\n  const storeExecutor = store[commitOrDispatch];\n  return typeof payload === 'function'\n    ? wirePayload => {\n        return storeExecutor(\n          mutationOrAction,\n          payload({\n            state: store.state,\n            getters: store.getters,\n            ...wirePayload\n          })\n        );\n      }\n    : payload !== undefined\n    ? () => {\n        storeExecutor(mutationOrAction, payload);\n      }\n    : observableValue => {\n        storeExecutor(mutationOrAction, observableValue.eventPayload);\n      };\n}\n"],"names":[],"mappings":"AAaA;;;;;;;AAOG;AACG,SAAU,sBAAsB,CACpC,EAA6C,EAAA;AAE7C,IAAA,OAAO,CAAC,UAAU,EAAE,KAAK,KACvB,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAI;QAClD,EAAE,CAAC,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;AACxC,KAAC,CAAC,CAAC;AACP,CAAC;AAuCD;AACgB,SAAA,UAAU,CAAU,QAAgB,EAAE,OAAiB,EAAA;IACrE,OAAO,CAAC,UAAU,EAAE,KAAK,KACvB,UAAU,CAAC,SAAS,CAAC,0BAA0B,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;AACzF,CAAC;AAED;;;;;;;AAOG;AACG,SAAU,wBAAwB,CAAC,QAAgB,EAAA;IACvD,OAAO,CAAC,UAAU,EAAE,KAAK,KAAK,UAAU,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;AACnF,CAAC;AAuCD;AACgB,SAAA,YAAY,CAAU,MAAc,EAAE,OAAiB,EAAA;IACrE,OAAO,CAAC,UAAU,EAAE,KAAK,KACvB,UAAU,CAAC,SAAS,CAAC,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AACzF,CAAC;AAED;;;;;;;AAOG;AACG,SAAU,0BAA0B,CAAC,MAAc,EAAA;IACvD,OAAO,CAAC,UAAU,EAAE,KAAK,KAAK,UAAU,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;AACnF,CAAC;AAED;;;;;;AAMG;AACG,SAAU,WAAW,CACzB,OAA8D,EAAA;AAE9D,IAAA,OAAO,CAAC,MAAM,EAAE,OAAQ,KAAI;QAC1B,OAAO,UAAU,IACf,UAAU,CAAC,SAAS,CAClB,OAAO,KAAK,SAAS;cACjB,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC;AAChC,cAAE,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC,YAAY,CAAC,CACzE,CAAC;AACN,KAAC,CAAC;AACJ,CAAC;AAED;;;;;;;AAOG;AACG,SAAU,yBAAyB,CACvC,OAA8D,EAAA;IAE9D,OAAO,MAAM,IAAG;AACd,QAAA,OAAO,UAAU,IAAI,UAAU,CAAC,SAAS,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AACrE,KAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;AAaG;AACH,SAAS,0BAA0B,CACjC,KAA6B,EAC7B,gBAAuC,EACvC,gBAAwB,EACxB,OAAiB,EAAA;AAEjB,IAAA,MAAM,aAAa,GAAG,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAC9C,OAAO,OAAO,OAAO,KAAK,UAAU;UAChC,WAAW,IAAG;AACZ,YAAA,OAAO,aAAa,CAClB,gBAAgB,EAChB,OAAO,CAAC;gBACN,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,OAAO,EAAE,KAAK,CAAC,OAAO;AACtB,gBAAA,GAAG,WAAW;AACf,aAAA,CAAC,CACH,CAAC;SACH;UACD,OAAO,KAAK,SAAS;cACrB,MAAK;AACH,gBAAA,aAAa,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;aAC1C;cACD,eAAe,IAAG;AAChB,gBAAA,aAAa,CAAC,gBAAgB,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC;AAChE,aAAC,CAAC;AACR;;;;"}

package/js/wiring/wires.operators.js

@@ -1,6 +1,5 @@
-import { __assign, __spreadArray, __rest } from 'tslib';
-import { filter as filter$1, throttle as throttle$1, map, debounce as debounce$1 } from 'rxjs/operators';
-import { handleTimedWire } from './utils/wire-racing-handling.js';
+import { filter as filter$1, debounce as debounce$1, throttle as throttle$1, map } from 'rxjs/operators';
+import { createTimer, normalizeTime } from './wires-operators.utils.js';
 
 /**
  * Creates a {@link Wire} that is only executed whenever the condition in the filterFn is true.
@@ -13,9 +12,7 @@ import { handleTimedWire } from './utils/wire-racing-handling.js';
  * @public
  */
 function filter(wire, filterFn) {
-    return function (observable, store, on) {
-        return wire(observable.pipe(filter$1(function (wirePayload) { return filterFn(__assign(__assign({}, wirePayload), { store: store })); })), store, on);
-    };
+    return (observable, store, on) => wire(observable.pipe(filter$1(wirePayload => filterFn({ ...wirePayload, store }))), store, on);
 }
 /**
  * Creates a {@link Wire} that is only executed when the payload is truthy. A truthy value is
@@ -27,10 +24,7 @@ function filter(wire, filterFn) {
  * @public
  */
 function filterFalsyPayload(wire) {
-    return filter(wire, function (_a) {
-        var eventPayload = _a.eventPayload;
-        return !!eventPayload;
-    });
+    return filter(wire, ({ eventPayload }) => !!eventPayload);
 }
 /**
  * Creates a {@link Wire} that is only executed when the payload is a
@@ -42,10 +36,7 @@ function filterFalsyPayload(wire) {
  * @public
  */
 function filterTruthyPayload(wire) {
-    return filter(wire, function (_a) {
-        var eventPayload = _a.eventPayload;
-        return !eventPayload;
-    });
+    return filter(wire, ({ eventPayload }) => !eventPayload);
 }
 /**
  * Creates a {@link Wire} that is only executed if the event is emitted from a {@link XModule}
@@ -59,11 +50,8 @@ function filterTruthyPayload(wire) {
  * @public
  */
 function filterWhitelistedModules(wire, whitelist) {
-    var whitelistSet = new Set(whitelist);
-    return filter(wire, function (_a) {
-        var metadata = _a.metadata;
-        return whitelistSet.has(metadata.moduleName);
-    });
+    const whitelistSet = new Set(whitelist);
+    return filter(wire, ({ metadata }) => whitelistSet.has(metadata.moduleName));
 }
 /**
  * Creates a {@link Wire} that is only executed if the event is emitted from a {@link XModule}
@@ -77,11 +65,8 @@ function filterWhitelistedModules(wire, whitelist) {
  * @public
  */
 function filterBlacklistedModules(wire, blacklist) {
-    var blacklistSet = new Set(blacklist);
-    return filter(wire, function (_a) {
-        var metadata = _a.metadata;
-        return !blacklistSet.has(metadata.moduleName);
-    });
+    const blacklistSet = new Set(blacklist);
+    return filter(wire, ({ metadata }) => !blacklistSet.has(metadata.moduleName));
 }
 /**
  * Creates a debounced {@link Wire}. Being debounced means that it will only be executed after
@@ -90,15 +75,15 @@ function filterBlacklistedModules(wire, blacklist) {
  * @param wire - The wire to debounce.
  * @param timeInMs - The time in milliseconds to debounce the wire execution or a function to
  * retrieve it from the store.
- * @param raceEvent - The event or events that would prevent the wire execution if at least one
- * of them executes first.
+ * @param options - Options to configure this wire with, like an event to force it or cancel it.
  * @returns The Wire function with a debounced timing.
  *
  * @public
  */
-function debounce(wire, timeInMs, raceEvent) {
-    if (raceEvent === void 0) { raceEvent = []; }
-    return handleTimedWire(wire, timeInMs, debounce$1, raceEvent);
+function debounce(wire, timeInMs, options = {}) {
+    return (observable, store, on) => {
+        return wire(observable.pipe(debounce$1(() => createTimer(normalizeTime(timeInMs, store), options, on))), store, on);
+    };
 }
 /**
  * Creates a throttled {@link Wire}. Being throttled means that it will only be executed once
@@ -107,15 +92,18 @@ function debounce(wire, timeInMs, raceEvent) {
  * @param wire - The wire to throttle.
  * @param timeInMs - The time in milliseconds to throttle the wire execution or a function to
  * retrieve it from the store.
- * @param raceEvent - The event or events that would prevent the wire execution if at least one
- * of them executes first.
+ * @param options - Options to configure this wire with, like an event to force it or cancel it.
  * @returns The Wire function with a throttle timing.
  *
  * @public
  */
-function throttle(wire, timeInMs, raceEvent) {
-    if (raceEvent === void 0) { raceEvent = []; }
-    return handleTimedWire(wire, timeInMs, throttle$1, raceEvent);
+function throttle(wire, timeInMs, options = {}) {
+    return (observable, store, on) => {
+        return wire(observable.pipe(throttle$1(() => createTimer(normalizeTime(timeInMs, store), options, on), {
+            leading: true,
+            trailing: true
+        })), store, on);
+    };
 }
 /**
  * Creates a {@link Wire} from other `toWire` wire. It uses `mapFn` to transform the
@@ -129,16 +117,10 @@ function throttle(wire, timeInMs, raceEvent) {
  * @public
  */
 function mapWire(toWire, mapFn) {
-    return function (observable) {
-        var restWireParams = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            restWireParams[_i - 1] = arguments[_i];
-        }
-        return toWire.apply(void 0, __spreadArray([observable.pipe(map(function (_a) {
-                var eventPayload = _a.eventPayload, restWirePayload = __rest(_a, ["eventPayload"]);
-                return (__assign({ eventPayload: mapFn(eventPayload) }, restWirePayload));
-            }))], restWireParams));
-    };
+    return (observable, ...restWireParams) => toWire(observable.pipe(map(({ eventPayload, ...restWirePayload }) => ({
+        eventPayload: mapFn(eventPayload),
+        ...restWirePayload
+    }))), ...restWireParams);
 }
 
 export { debounce, filter, filterBlacklistedModules, filterFalsyPayload, filterTruthyPayload, filterWhitelistedModules, mapWire, throttle };

package/js/wiring/wires.operators.js.map

@@ -1 +1 @@
-{"version":3,"file":"wires.operators.js","sources":["../../../src/wiring/wires.operators.ts"],"sourcesContent":["import {\n  debounce as debounceRx,\n  filter as filterRx,\n  map,\n  throttle as throttleRx\n} from 'rxjs/operators';\nimport { XModuleName } from '../x-modules/x-modules.types';\nimport { XEvent } from './events.types';\nimport { handleTimedWire } from './utils/wire-racing-handling';\nimport { TimeRetrieving, Wire, WireParams } from './wiring.types';\n\n/**\n * Creates a {@link Wire} that is only executed whenever the condition in the filterFn is true.\n *\n * @param wire - The wire to filter.\n * @param filterFn - A function which must return a boolean and that will be executed every time\n * the wire is called.\n * @returns The Wire function filter.\n *\n * @public\n */\nexport function filter<Payload>(\n  wire: Wire<Payload>,\n  filterFn: (parameters: WireParams<Payload>) => boolean\n): Wire<Payload> {\n  return (observable, store, on) =>\n    wire(observable.pipe(filterRx(wirePayload => filterFn({ ...wirePayload, store }))), store, on);\n}\n\n/**\n * Creates a {@link Wire} that is only executed when the payload is truthy. A truthy value is\n * whatever is not a {@link https://developer.mozilla.org/en-US/docs/Glossary/Falsy | falsy value}.\n *\n * @param wire - The wire to avoid executing when the payload is falsy.\n * @returns The Wire function falsy filter.\n *\n * @public\n */\nexport function filterFalsyPayload<Payload>(wire: Wire<Payload>): Wire<Payload> {\n  return filter(wire, ({ eventPayload }) => !!eventPayload);\n}\n\n/**\n * Creates a {@link Wire} that is only executed when the payload is a\n * {@link https://developer.mozilla.org/en-US/docs/Glossary/Falsy | falsy value}.\n *\n * @param wire - The wire to avoid executing when the payload is truthy.\n * @returns The Wire function truthy filter.\n *\n * @public\n */\nexport function filterTruthyPayload<Payload>(wire: Wire<Payload>): Wire<Payload> {\n  return filter(wire, ({ eventPayload }) => !eventPayload);\n}\n\n/**\n * Creates a {@link Wire} that is only executed if the event is emitted from a {@link XModule}\n * that is included\n * in the `whitelist` array passed as parameter.\n *\n * @param wire - The wire to filter using the whitelist.\n * @param whitelist - An array of {@link XModuleName} or null.\n * @returns The Wire function with whitelisted modules filter.\n *\n * @public\n */\nexport function filterWhitelistedModules<Payload>(\n  wire: Wire<Payload>,\n  whitelist: Array<XModuleName | null>\n): Wire<Payload> {\n  const whitelistSet = new Set(whitelist);\n  return filter(wire, ({ metadata }) => whitelistSet.has(metadata.moduleName));\n}\n\n/**\n * Creates a {@link Wire} that is only executed if the event is emitted from a {@link XModule}\n * that is NOT included\n * in the `blacklist` array passed as parameter.\n *\n * @param wire - The wire to filter using the whitelist.\n * @param blacklist - An array of {@link XModuleName} or null.\n * @returns The Wire function with blacklisted modules filter.\n *\n * @public\n */\nexport function filterBlacklistedModules<Payload>(\n  wire: Wire<Payload>,\n  blacklist: Array<XModuleName | null>\n): Wire<Payload> {\n  const blacklistSet = new Set(blacklist);\n  return filter(wire, ({ metadata }) => !blacklistSet.has(metadata.moduleName));\n}\n\n/**\n * Creates a debounced {@link Wire}. Being debounced means that it will only be executed after\n * the time given by `timeInMs` has passed without invoking it.\n *\n * @param wire - The wire to debounce.\n * @param timeInMs - The time in milliseconds to debounce the wire execution or a function to\n * retrieve it from the store.\n * @param raceEvent - The event or events that would prevent the wire execution if at least one\n * of them executes first.\n * @returns The Wire function with a debounced timing.\n *\n * @public\n */\nexport function debounce<Payload>(\n  wire: Wire<Payload>,\n  timeInMs: TimeRetrieving | number,\n  raceEvent: XEvent | XEvent[] = []\n): Wire<Payload> {\n  return handleTimedWire(wire, timeInMs, debounceRx, raceEvent);\n}\n\n/**\n * Creates a throttled {@link Wire}. Being throttled means that it will only be executed once\n * every couple of milliseconds given by the `timeInMs` parameter.\n *\n * @param wire - The wire to throttle.\n * @param timeInMs - The time in milliseconds to throttle the wire execution or a function to\n * retrieve it from the store.\n * @param raceEvent - The event or events that would prevent the wire execution if at least one\n * of them executes first.\n * @returns The Wire function with a throttle timing.\n *\n * @public\n */\nexport function throttle<Payload>(\n  wire: Wire<Payload>,\n  timeInMs: TimeRetrieving | number,\n  raceEvent: XEvent | XEvent[] = []\n): Wire<Payload> {\n  return handleTimedWire(wire, timeInMs, throttleRx, raceEvent);\n}\n\n/**\n * Creates a {@link Wire} from other `toWire` wire. It uses `mapFn` to transform the\n * `FromPayload` received to `ToPayload` which `toWire` requires. This is\n * useful to reuse wires in different Events where the payload doesn't fit exactly.\n *\n * @param toWire - The wire which the new Wire is created from.\n * @param mapFn - Function to map the payload from `FromPayload` to `ToPayload`.\n * @returns A new {@link Wire}.\n *\n * @public\n */\nexport function mapWire<FromPayload, ToPayload>(\n  toWire: Wire<ToPayload>,\n  mapFn: (payload: FromPayload) => ToPayload\n): Wire<FromPayload> {\n  return (observable, ...restWireParams) =>\n    toWire(\n      observable.pipe(\n        map(({ eventPayload, ...restWirePayload }) => ({\n          eventPayload: mapFn(eventPayload),\n          ...restWirePayload\n        }))\n      ),\n      ...restWireParams\n    );\n}\n"],"names":["filterRx","debounceRx","throttleRx"],"mappings":";;;;AAWA;;;;;;;;;;SAUgB,MAAM,CACpB,IAAmB,EACnB,QAAsD;IAEtD,OAAO,UAAC,UAAU,EAAE,KAAK,EAAE,EAAE;QAC3B,OAAA,IAAI,CAAC,UAAU,CAAC,IAAI,CAACA,QAAQ,CAAC,UAAA,WAAW,IAAI,OAAA,QAAQ,uBAAM,WAAW,KAAE,KAAK,OAAA,IAAG,GAAA,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;KAAA,CAAC;AACnG,CAAC;AAED;;;;;;;;;SASgB,kBAAkB,CAAU,IAAmB;IAC7D,OAAO,MAAM,CAAC,IAAI,EAAE,UAAC,EAAgB;YAAd,YAAY,kBAAA;QAAO,OAAA,CAAC,CAAC,YAAY;KAAA,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;;;;SASgB,mBAAmB,CAAU,IAAmB;IAC9D,OAAO,MAAM,CAAC,IAAI,EAAE,UAAC,EAAgB;YAAd,YAAY,kBAAA;QAAO,OAAA,CAAC,YAAY;KAAA,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;;SAWgB,wBAAwB,CACtC,IAAmB,EACnB,SAAoC;IAEpC,IAAM,YAAY,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;IACxC,OAAO,MAAM,CAAC,IAAI,EAAE,UAAC,EAAY;YAAV,QAAQ,cAAA;QAAO,OAAA,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC;KAAA,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;;;;;SAWgB,wBAAwB,CACtC,IAAmB,EACnB,SAAoC;IAEpC,IAAM,YAAY,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;IACxC,OAAO,MAAM,CAAC,IAAI,EAAE,UAAC,EAAY;YAAV,QAAQ,cAAA;QAAO,OAAA,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC;KAAA,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;SAagB,QAAQ,CACtB,IAAmB,EACnB,QAAiC,EACjC,SAAiC;IAAjC,0BAAA,EAAA,cAAiC;IAEjC,OAAO,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAEC,UAAU,EAAE,SAAS,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;;;SAagB,QAAQ,CACtB,IAAmB,EACnB,QAAiC,EACjC,SAAiC;IAAjC,0BAAA,EAAA,cAAiC;IAEjC,OAAO,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAEC,UAAU,EAAE,SAAS,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;SAWgB,OAAO,CACrB,MAAuB,EACvB,KAA0C;IAE1C,OAAO,UAAC,UAAU;QAAE,wBAAiB;aAAjB,UAAiB,EAAjB,qBAAiB,EAAjB,IAAiB;YAAjB,uCAAiB;;QACnC,OAAA,MAAM,8BACJ,UAAU,CAAC,IAAI,CACb,GAAG,CAAC,UAAC,EAAoC;gBAAlC,IAAA,YAAY,kBAAA,EAAK,eAAe,cAAlC,gBAAoC,CAAF;gBAAO,mBAC5C,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,IAC9B,eAAe,GAClB;aAAA,CAAC,CACJ,GACE,cAAc;KAClB,CAAC;AACN;;;;"}
+{"version":3,"file":"wires.operators.js","sources":["../../../src/wiring/wires.operators.ts"],"sourcesContent":["import {\n  debounce as debounceRx,\n  filter as filterRx,\n  map,\n  throttle as throttleRx\n} from 'rxjs/operators';\nimport { XModuleName } from '../x-modules/x-modules.types';\nimport { createTimer, normalizeTime } from './wires-operators.utils';\nimport { TimedWireOperatorOptions, TimeSelector, Wire, WireParams } from './wiring.types';\n\n/**\n * Creates a {@link Wire} that is only executed whenever the condition in the filterFn is true.\n *\n * @param wire - The wire to filter.\n * @param filterFn - A function which must return a boolean and that will be executed every time\n * the wire is called.\n * @returns The Wire function filter.\n *\n * @public\n */\nexport function filter<Payload>(\n  wire: Wire<Payload>,\n  filterFn: (parameters: WireParams<Payload>) => boolean\n): Wire<Payload> {\n  return (observable, store, on) =>\n    wire(observable.pipe(filterRx(wirePayload => filterFn({ ...wirePayload, store }))), store, on);\n}\n\n/**\n * Creates a {@link Wire} that is only executed when the payload is truthy. A truthy value is\n * whatever is not a {@link https://developer.mozilla.org/en-US/docs/Glossary/Falsy | falsy value}.\n *\n * @param wire - The wire to avoid executing when the payload is falsy.\n * @returns The Wire function falsy filter.\n *\n * @public\n */\nexport function filterFalsyPayload<Payload>(wire: Wire<Payload>): Wire<Payload> {\n  return filter(wire, ({ eventPayload }) => !!eventPayload);\n}\n\n/**\n * Creates a {@link Wire} that is only executed when the payload is a\n * {@link https://developer.mozilla.org/en-US/docs/Glossary/Falsy | falsy value}.\n *\n * @param wire - The wire to avoid executing when the payload is truthy.\n * @returns The Wire function truthy filter.\n *\n * @public\n */\nexport function filterTruthyPayload<Payload>(wire: Wire<Payload>): Wire<Payload> {\n  return filter(wire, ({ eventPayload }) => !eventPayload);\n}\n\n/**\n * Creates a {@link Wire} that is only executed if the event is emitted from a {@link XModule}\n * that is included\n * in the `whitelist` array passed as parameter.\n *\n * @param wire - The wire to filter using the whitelist.\n * @param whitelist - An array of {@link XModuleName} or null.\n * @returns The Wire function with whitelisted modules filter.\n *\n * @public\n */\nexport function filterWhitelistedModules<Payload>(\n  wire: Wire<Payload>,\n  whitelist: Array<XModuleName | null>\n): Wire<Payload> {\n  const whitelistSet = new Set(whitelist);\n  return filter(wire, ({ metadata }) => whitelistSet.has(metadata.moduleName));\n}\n\n/**\n * Creates a {@link Wire} that is only executed if the event is emitted from a {@link XModule}\n * that is NOT included\n * in the `blacklist` array passed as parameter.\n *\n * @param wire - The wire to filter using the whitelist.\n * @param blacklist - An array of {@link XModuleName} or null.\n * @returns The Wire function with blacklisted modules filter.\n *\n * @public\n */\nexport function filterBlacklistedModules<Payload>(\n  wire: Wire<Payload>,\n  blacklist: Array<XModuleName | null>\n): Wire<Payload> {\n  const blacklistSet = new Set(blacklist);\n  return filter(wire, ({ metadata }) => !blacklistSet.has(metadata.moduleName));\n}\n\n/**\n * Creates a debounced {@link Wire}. Being debounced means that it will only be executed after\n * the time given by `timeInMs` has passed without invoking it.\n *\n * @param wire - The wire to debounce.\n * @param timeInMs - The time in milliseconds to debounce the wire execution or a function to\n * retrieve it from the store.\n * @param options - Options to configure this wire with, like an event to force it or cancel it.\n * @returns The Wire function with a debounced timing.\n *\n * @public\n */\nexport function debounce<Payload>(\n  wire: Wire<Payload>,\n  timeInMs: TimeSelector | number,\n  options: TimedWireOperatorOptions = {}\n): Wire<Payload> {\n  return (observable, store, on) => {\n    return wire(\n      observable.pipe(debounceRx(() => createTimer(normalizeTime(timeInMs, store), options, on))),\n      store,\n      on\n    );\n  };\n}\n\n/**\n * Creates a throttled {@link Wire}. Being throttled means that it will only be executed once\n * every couple of milliseconds given by the `timeInMs` parameter.\n *\n * @param wire - The wire to throttle.\n * @param timeInMs - The time in milliseconds to throttle the wire execution or a function to\n * retrieve it from the store.\n * @param options - Options to configure this wire with, like an event to force it or cancel it.\n * @returns The Wire function with a throttle timing.\n *\n * @public\n */\nexport function throttle<Payload>(\n  wire: Wire<Payload>,\n  timeInMs: TimeSelector | number,\n  options: TimedWireOperatorOptions = {}\n): Wire<Payload> {\n  return (observable, store, on) => {\n    return wire(\n      observable.pipe(\n        throttleRx(() => createTimer(normalizeTime(timeInMs, store), options, on), {\n          leading: true,\n          trailing: true\n        })\n      ),\n      store,\n      on\n    );\n  };\n}\n\n/**\n * Creates a {@link Wire} from other `toWire` wire. It uses `mapFn` to transform the\n * `FromPayload` received to `ToPayload` which `toWire` requires. This is\n * useful to reuse wires in different Events where the payload doesn't fit exactly.\n *\n * @param toWire - The wire which the new Wire is created from.\n * @param mapFn - Function to map the payload from `FromPayload` to `ToPayload`.\n * @returns A new {@link Wire}.\n *\n * @public\n */\nexport function mapWire<FromPayload, ToPayload>(\n  toWire: Wire<ToPayload>,\n  mapFn: (payload: FromPayload) => ToPayload\n): Wire<FromPayload> {\n  return (observable, ...restWireParams) =>\n    toWire(\n      observable.pipe(\n        map(({ eventPayload, ...restWirePayload }) => ({\n          eventPayload: mapFn(eventPayload),\n          ...restWirePayload\n        }))\n      ),\n      ...restWireParams\n    );\n}\n"],"names":["filterRx","debounceRx","throttleRx"],"mappings":";;;AAUA;;;;;;;;;AASG;AACa,SAAA,MAAM,CACpB,IAAmB,EACnB,QAAsD,EAAA;AAEtD,IAAA,OAAO,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,KAC3B,IAAI,CAAC,UAAU,CAAC,IAAI,CAACA,QAAQ,CAAC,WAAW,IAAI,QAAQ,CAAC,EAAE,GAAG,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;AACnG,CAAC;AAED;;;;;;;;AAQG;AACG,SAAU,kBAAkB,CAAU,IAAmB,EAAA;AAC7D,IAAA,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;;;AAQG;AACG,SAAU,mBAAmB,CAAU,IAAmB,EAAA;AAC9D,IAAA,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;AAUG;AACa,SAAA,wBAAwB,CACtC,IAAmB,EACnB,SAAoC,EAAA;AAEpC,IAAA,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;IACxC,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;;;;AAUG;AACa,SAAA,wBAAwB,CACtC,IAAmB,EACnB,SAAoC,EAAA;AAEpC,IAAA,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;IACxC,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;AAWG;AACG,SAAU,QAAQ,CACtB,IAAmB,EACnB,QAA+B,EAC/B,UAAoC,EAAE,EAAA;AAEtC,IAAA,OAAO,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,KAAI;AAC/B,QAAA,OAAO,IAAI,CACT,UAAU,CAAC,IAAI,CAACC,UAAU,CAAC,MAAM,WAAW,CAAC,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC,EAC3F,KAAK,EACL,EAAE,CACH,CAAC;AACJ,KAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;AAWG;AACG,SAAU,QAAQ,CACtB,IAAmB,EACnB,QAA+B,EAC/B,UAAoC,EAAE,EAAA;AAEtC,IAAA,OAAO,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,KAAI;QAC/B,OAAO,IAAI,CACT,UAAU,CAAC,IAAI,CACbC,UAAU,CAAC,MAAM,WAAW,CAAC,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE;AACzE,YAAA,OAAO,EAAE,IAAI;AACb,YAAA,QAAQ,EAAE,IAAI;AACf,SAAA,CAAC,CACH,EACD,KAAK,EACL,EAAE,CACH,CAAC;AACJ,KAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;AAUG;AACa,SAAA,OAAO,CACrB,MAAuB,EACvB,KAA0C,EAAA;IAE1C,OAAO,CAAC,UAAU,EAAE,GAAG,cAAc,KACnC,MAAM,CACJ,UAAU,CAAC,IAAI,CACb,GAAG,CAAC,CAAC,EAAE,YAAY,EAAE,GAAG,eAAe,EAAE,MAAM;AAC7C,QAAA,YAAY,EAAE,KAAK,CAAC,YAAY,CAAC;AACjC,QAAA,GAAG,eAAe;AACnB,KAAA,CAAC,CAAC,CACJ,EACD,GAAG,cAAc,CAClB,CAAC;AACN;;;;"}

package/js/wiring/wiring.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"wiring.utils.js","sources":["../../../src/wiring/wiring.utils.ts"],"sourcesContent":["import { Store } from 'vuex';\nimport { RootXStoreState, StoreModuleStateAndGetters } from '../store/store.types';\nimport { getGettersProxy } from '../store/utils/getters-proxy.utils';\nimport { ExtractState, XModuleName } from '../x-modules/x-modules.types';\nimport { Wiring } from './wiring.types';\n\n/**\n * Util function to generate type-safe wiring.\n * If TypeScript ever accepts the PR about generic type inference this function can be removed.\n *\n * @param wiring - The wiring to create.\n * @returns Type-safe wiring.\n *\n * @public\n */\nexport function createWiring<T extends Partial<Wiring>>(wiring: T): T {\n  return wiring;\n}\n\n/**\n * Returns an object with the getters and state of a module of store defined by the moduleName\n * parameter.\n *\n * @param state - The Vuex store State.\n * @param getters - The Vuex store Getters.\n * @param moduleName - The {@link XModuleName} of the module.\n * @returns The {@link StoreModuleStateAndGetters} with the Getters and the State of the\n * {@link XStoreModule | Store Module} defined by moduleName.\n *\n * @public\n */\nexport function getStateAndGettersFromModule<ModuleName extends XModuleName>(\n  state: RootXStoreState,\n  getters: Pick<Store<any>, 'getters'>,\n  moduleName: ModuleName\n): StoreModuleStateAndGetters<ModuleName> {\n  return {\n    state: state.x[moduleName] as unknown as ExtractState<ModuleName>,\n    getters: getGettersProxy(getters, moduleName)\n  };\n}\n"],"names":[],"mappings":";;AAMA;;;;;;;;;SASgB,YAAY,CAA4B,MAAS;IAC/D,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;SAYgB,4BAA4B,CAC1C,KAAsB,EACtB,OAAoC,EACpC,UAAsB;IAEtB,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,UAAU,CAAwC;QACjE,OAAO,EAAE,eAAe,CAAC,OAAO,EAAE,UAAU,CAAC;KAC9C,CAAC;AACJ;;;;"}
+{"version":3,"file":"wiring.utils.js","sources":["../../../src/wiring/wiring.utils.ts"],"sourcesContent":["import { Store } from 'vuex';\nimport { RootXStoreState, StoreModuleStateAndGetters } from '../store/store.types';\nimport { getGettersProxy } from '../store/utils/getters-proxy.utils';\nimport { ExtractState, XModuleName } from '../x-modules/x-modules.types';\nimport { Wiring } from './wiring.types';\n\n/**\n * Util function to generate type-safe wiring.\n * If TypeScript ever accepts the PR about generic type inference this function can be removed.\n *\n * @param wiring - The wiring to create.\n * @returns Type-safe wiring.\n *\n * @public\n */\nexport function createWiring<T extends Partial<Wiring>>(wiring: T): T {\n  return wiring;\n}\n\n/**\n * Returns an object with the getters and state of a module of store defined by the moduleName\n * parameter.\n *\n * @param state - The Vuex store State.\n * @param getters - The Vuex store Getters.\n * @param moduleName - The {@link XModuleName} of the module.\n * @returns The {@link StoreModuleStateAndGetters} with the Getters and the State of the\n * {@link XStoreModule | Store Module} defined by moduleName.\n *\n * @public\n */\nexport function getStateAndGettersFromModule<ModuleName extends XModuleName>(\n  state: RootXStoreState,\n  getters: Pick<Store<any>, 'getters'>,\n  moduleName: ModuleName\n): StoreModuleStateAndGetters<ModuleName> {\n  return {\n    state: state.x[moduleName] as unknown as ExtractState<ModuleName>,\n    getters: getGettersProxy(getters, moduleName)\n  };\n}\n"],"names":[],"mappings":";;AAMA;;;;;;;;AAQG;AACG,SAAU,YAAY,CAA4B,MAAS,EAAA;AAC/D,IAAA,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;AAWG;SACa,4BAA4B,CAC1C,KAAsB,EACtB,OAAoC,EACpC,UAAsB,EAAA;IAEtB,OAAO;AACL,QAAA,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,UAAU,CAAwC;AACjE,QAAA,OAAO,EAAE,eAAe,CAAC,OAAO,EAAE,UAAU,CAAC;KAC9C,CAAC;AACJ;;;;"}

package/js/x-installer/api/base-api.js

@@ -3,8 +3,8 @@
  *
  * @public
  */
-var BaseXAPI = /** @class */ (function () {
-    function BaseXAPI() {
+class BaseXAPI {
+    constructor() {
         /**
          * Flag to check if the initialization was already done.
          *
@@ -12,6 +12,14 @@ var BaseXAPI = /** @class */ (function () {
          */
         this.isXInitialized = false;
     }
+    /**
+     * Tracks that a product was added to cart from PDP.
+     *
+     * @param productId - The product id that was added to cart.
+     */
+    addProductToCart(productId) {
+        this.bus?.emit('UserClickedPDPAddToCart', productId);
+    }
     /**
      * Setter for the {@link XBus}.
      *
@@ -19,17 +27,37 @@ var BaseXAPI = /** @class */ (function () {
      *
      * @internal
      */
-    BaseXAPI.prototype.setBus = function (bus) {
+    setBus(bus) {
         this.bus = bus;
-    };
+    }
     /**
      * Setter for the callback to call in the init method.
      *
      * @param initCallback - The callback to call.
      */
-    BaseXAPI.prototype.setInitCallback = function (initCallback) {
+    setInitCallback(initCallback) {
         this.initCallback = initCallback;
-    };
+    }
+    /**
+     * Setter for the callback to modify the snippet config.
+     *
+     * @param snippetCallback - The callback to call.
+     *
+     * @internal
+     */
+    setSnippetConfigCallback(snippetCallback) {
+        this.snippetCallback = snippetCallback;
+    }
+    /**
+     * Sets or updates the snippet config.
+     *
+     * @param config - A part or all the snippet config.
+     *
+     * @public
+     */
+    setSnippetConfig(config) {
+        this?.snippetCallback(config);
+    }
     /**
      * Searches the query parameter as user query.
      *
@@ -37,32 +65,30 @@ var BaseXAPI = /** @class */ (function () {
      *
      * @public
      */
-    BaseXAPI.prototype.search = function (query) {
-        var _a, _b;
+    search(query) {
         if (query) {
-            (_a = this.bus) === null || _a === void 0 ? void 0 : _a.emit('UserAcceptedAQuery', query);
+            this.bus?.emit('UserAcceptedAQuery', query);
         }
-        (_b = this.bus) === null || _b === void 0 ? void 0 : _b.emit('UserOpenXProgrammatically');
-    };
+        this.bus?.emit('UserClickedOpenX');
+    }
     /**
      * Initializes the Application passing the {@link SnippetConfig}.
      *
-     * @param config - The config comming from the customer snippet.
+     * @param config - The config coming from the customer snippet.
      *
      * @public
      */
-    BaseXAPI.prototype.init = function (config) {
+    init(config) {
         if (!this.isXInitialized) {
             this.isXInitialized = true;
-            this === null || this === void 0 ? void 0 : this.initCallback(config);
+            this?.initCallback(config);
         }
         else {
             //eslint-disable-next-line no-console
             console.warn('We know X is awesome, but you only need to initialize it once.');
         }
-    };
-    return BaseXAPI;
-}());
+    }
+}
 
 export { BaseXAPI };
 //# sourceMappingURL=base-api.js.map

package/js/x-installer/api/base-api.js.map

@@ -1 +1 @@
-{"version":3,"file":"base-api.js","sources":["../../../../src/x-installer/api/base-api.ts"],"sourcesContent":["import { XBus } from '../../plugins/x-bus.types';\nimport { SnippetConfig, XAPI } from './api.types';\n\n/**\n * Default implementation for {@link XAPI}.\n *\n * @public\n */\nexport class BaseXAPI implements XAPI {\n  /**\n   * Flag to check if the initialization was already done.\n   *\n   * @internal\n   */\n  protected isXInitialized = false;\n\n  /**\n   * Bus for emitting and listening events.\n   *\n   * @internal\n   */\n  protected bus!: XBus;\n\n  /**\n   * The callback to call from the init method. The logic of initialization is out of this API\n   * since this API is just a facade.\n   *\n   * @internal\n   */\n  protected initCallback!: (config: SnippetConfig) => any;\n\n  /**\n   * Setter for the {@link XBus}.\n   *\n   * @param bus - The {@link XBus} received to emit events.\n   *\n   * @internal\n   */\n  setBus(bus: XBus): void {\n    this.bus = bus;\n  }\n\n  /**\n   * Setter for the callback to call in the init method.\n   *\n   * @param initCallback - The callback to call.\n   */\n  setInitCallback(initCallback: (config: SnippetConfig) => any): void {\n    this.initCallback = initCallback;\n  }\n\n  /**\n   * Searches the query parameter as user query.\n   *\n   * @param query - Query to be searched.\n   *\n   * @public\n   */\n  search(query?: string): void {\n    if (query) {\n      this.bus?.emit('UserAcceptedAQuery', query);\n    }\n    this.bus?.emit('UserOpenXProgrammatically');\n  }\n\n  /**\n   * Initializes the Application passing the {@link SnippetConfig}.\n   *\n   * @param config - The config comming from the customer snippet.\n   *\n   * @public\n   */\n  init(config: SnippetConfig): void {\n    if (!this.isXInitialized) {\n      this.isXInitialized = true;\n      this?.initCallback(config);\n    } else {\n      //eslint-disable-next-line no-console\n      console.warn('We know X is awesome, but you only need to initialize it once.');\n    }\n  }\n}\n"],"names":[],"mappings":"AAGA;;;;;;IAKA;;;;;;QAMY,mBAAc,GAAG,KAAK,CAAC;KAmElC;;;;;;;;IA3CC,yBAAM,GAAN,UAAO,GAAS;QACd,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;KAChB;;;;;;IAOD,kCAAe,GAAf,UAAgB,YAA4C;QAC1D,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;KAClC;;;;;;;;IASD,yBAAM,GAAN,UAAO,KAAc;;QACnB,IAAI,KAAK,EAAE;YACT,MAAA,IAAI,CAAC,GAAG,0CAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;SAC7C;QACD,MAAA,IAAI,CAAC,GAAG,0CAAE,IAAI,CAAC,2BAA2B,CAAC,CAAC;KAC7C;;;;;;;;IASD,uBAAI,GAAJ,UAAK,MAAqB;QACxB,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;YACxB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,YAAY,CAAC,MAAM,CAAC,CAAC;SAC5B;aAAM;;YAEL,OAAO,CAAC,IAAI,CAAC,gEAAgE,CAAC,CAAC;SAChF;KACF;IACH,eAAC;AAAD,CAAC;;;;"}
+{"version":3,"file":"base-api.js","sources":["../../../../src/x-installer/api/base-api.ts"],"sourcesContent":["import { XBus } from '../../plugins/x-bus.types';\nimport { SnippetConfig, XAPI } from './api.types';\n\n/**\n * Default implementation for {@link XAPI}.\n *\n * @public\n */\nexport class BaseXAPI implements XAPI {\n  /**\n   * Flag to check if the initialization was already done.\n   *\n   * @internal\n   */\n  protected isXInitialized = false;\n\n  /**\n   * Bus for emitting and listening events.\n   *\n   * @internal\n   */\n  protected bus!: XBus;\n\n  /**\n   * The callback to call from the init method. The logic of initialization is out of this API\n   * since this API is just a facade.\n   *\n   * @internal\n   */\n  protected initCallback!: (config: SnippetConfig) => any;\n\n  /**\n   * Callback that allows to update the snippet config. The logic of initialization is out of this\n   * API since this API is just a facade.\n   *\n   * @internal\n   */\n  protected snippetCallback!: (config: Partial<SnippetConfig>) => void;\n\n  /**\n   * Tracks that a product was added to cart from PDP.\n   *\n   * @param productId - The product id that was added to cart.\n   */\n  addProductToCart(productId?: string): void {\n    this.bus?.emit('UserClickedPDPAddToCart', productId);\n  }\n\n  /**\n   * Setter for the {@link XBus}.\n   *\n   * @param bus - The {@link XBus} received to emit events.\n   *\n   * @internal\n   */\n  setBus(bus: XBus): void {\n    this.bus = bus;\n  }\n\n  /**\n   * Setter for the callback to call in the init method.\n   *\n   * @param initCallback - The callback to call.\n   */\n  setInitCallback(initCallback: (config: SnippetConfig) => any): void {\n    this.initCallback = initCallback;\n  }\n\n  /**\n   * Setter for the callback to modify the snippet config.\n   *\n   * @param snippetCallback - The callback to call.\n   *\n   * @internal\n   */\n  setSnippetConfigCallback(snippetCallback: (config: Partial<SnippetConfig>) => void): void {\n    this.snippetCallback = snippetCallback;\n  }\n\n  /**\n   * Sets or updates the snippet config.\n   *\n   * @param config - A part or all the snippet config.\n   *\n   * @public\n   */\n  setSnippetConfig(config: Partial<SnippetConfig>): void {\n    this?.snippetCallback(config);\n  }\n\n  /**\n   * Searches the query parameter as user query.\n   *\n   * @param query - Query to be searched.\n   *\n   * @public\n   */\n  search(query?: string): void {\n    if (query) {\n      this.bus?.emit('UserAcceptedAQuery', query);\n    }\n    this.bus?.emit('UserClickedOpenX');\n  }\n\n  /**\n   * Initializes the Application passing the {@link SnippetConfig}.\n   *\n   * @param config - The config coming from the customer snippet.\n   *\n   * @public\n   */\n  init(config: SnippetConfig): void {\n    if (!this.isXInitialized) {\n      this.isXInitialized = true;\n      this?.initCallback(config);\n    } else {\n      //eslint-disable-next-line no-console\n      console.warn('We know X is awesome, but you only need to initialize it once.');\n    }\n  }\n}\n"],"names":[],"mappings":"AAGA;;;;AAIG;MACU,QAAQ,CAAA;AAArB,IAAA,WAAA,GAAA;AACE;;;;AAIG;QACO,IAAc,CAAA,cAAA,GAAG,KAAK,CAAC;KA0GlC;AAjFC;;;;AAIG;AACH,IAAA,gBAAgB,CAAC,SAAkB,EAAA;QACjC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,yBAAyB,EAAE,SAAS,CAAC,CAAC;KACtD;AAED;;;;;;AAMG;AACH,IAAA,MAAM,CAAC,GAAS,EAAA;AACd,QAAA,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;KAChB;AAED;;;;AAIG;AACH,IAAA,eAAe,CAAC,YAA4C,EAAA;AAC1D,QAAA,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;KAClC;AAED;;;;;;AAMG;AACH,IAAA,wBAAwB,CAAC,eAAyD,EAAA;AAChF,QAAA,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;KACxC;AAED;;;;;;AAMG;AACH,IAAA,gBAAgB,CAAC,MAA8B,EAAA;AAC7C,QAAA,IAAI,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;KAC/B;AAED;;;;;;AAMG;AACH,IAAA,MAAM,CAAC,KAAc,EAAA;AACnB,QAAA,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;AAC7C,SAAA;AACD,QAAA,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;KACpC;AAED;;;;;;AAMG;AACH,IAAA,IAAI,CAAC,MAAqB,EAAA;AACxB,QAAA,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;AACxB,YAAA,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;AAC3B,YAAA,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;AAC5B,SAAA;AAAM,aAAA;;AAEL,YAAA,OAAO,CAAC,IAAI,CAAC,gEAAgE,CAAC,CAAC;AAChF,SAAA;KACF;AACF;;;;"}