ballerina-core 1.0.244 → 1.0.246

package/bin/src/async/domains/mirroring/domains/synchronized-entities/state.js

@@ -1,10 +1,7 @@
 import { simpleUpdater } from "ballerina-core";
 export const SynchronizedEntities = () => ({
-  Updaters: {
-    Core: Object.assign(
-      Object.assign({}, simpleUpdater()("singletons")),
-      simpleUpdater()("collections"),
-    ),
-  },
+    Updaters: {
+        Core: Object.assign(Object.assign({}, simpleUpdater()("singletons")), simpleUpdater()("collections")),
+    },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/promise/state.d.ts

@@ -1,12 +1,7 @@
 import { BasicFun } from "../../../fun/state";
 export declare const PromiseRepo: {
-  Default: {
-    mock: <T>(
-      value: BasicFun<void, T>,
-      error?: BasicFun<void, any>,
-      probabilityOfSuccess?: number,
-      averageDelay?: number,
-    ) => Promise<T>;
-  };
+    Default: {
+        mock: <T>(value: BasicFun<void, T>, error?: BasicFun<void, any>, probabilityOfSuccess?: number, averageDelay?: number) => Promise<T>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/async/domains/promise/state.js

@@ -1,23 +1,12 @@
 export const PromiseRepo = {
-  Default: {
-    mock: (
-      value,
-      error = () => "error",
-      probabilityOfSuccess = 1,
-      averageDelay = 0,
-    ) => {
-      const λ = 1 / averageDelay;
-      const delay = Math.log(1 - Math.random()) / -λ; // sample the exponential distribution
-      return new Promise((resolve, reject) =>
-        setTimeout(
-          () =>
-            Math.random() <= probabilityOfSuccess
-              ? resolve(value())
-              : reject(error()),
-          delay * 1000,
-        ),
-      );
+    Default: {
+        mock: (value, error = () => "error", probabilityOfSuccess = 1, averageDelay = 0) => {
+            const λ = 1 / averageDelay;
+            const delay = Math.log(1 - Math.random()) / -λ; // sample the exponential distribution
+            return new Promise((resolve, reject) => setTimeout(() => Math.random() <= probabilityOfSuccess
+                ? resolve(value())
+                : reject(error()), delay * 1000));
+        },
     },
-  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/synchronized/coroutines/synchronize.js

@@ -2,90 +2,38 @@ import { CoTypedFactory } from "../../../../coroutines/builder";
 import { id } from "../../../../fun/domains/id/state";
 import { AsyncState } from "../../../state";
 import { Synchronized } from "../state";
-export const Synchronize = (
-  p,
-  errorProcessor = () => "transient failure",
-  maxAttempts = 2,
-  delayBetweenAttemptsInMs = 250,
-) => {
-  const Co = CoTypedFactory();
-  return Co.SetState(
-    Synchronized.Updaters.sync(AsyncState.Updaters.toReloading()),
-  ).then(() =>
-    Co.GetState().then((current) =>
-      Co.Await(() => p(current), id).then((apiResult) => {
+export const Synchronize = (p, errorProcessor = () => "transient failure", maxAttempts = 2, delayBetweenAttemptsInMs = 250) => {
+    const Co = CoTypedFactory();
+    return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toReloading())).then(() => Co.GetState().then((current) => Co.Await(() => p(current), id).then((apiResult) => {
         if (apiResult.kind == "l") {
-          return Co.SetState(
-            Synchronized.Updaters.sync(
-              AsyncState.Updaters.toLoaded(apiResult.value),
-            ),
-          ).then(() => Co.Return("success"));
-        } else if (
-          errorProcessor(apiResult.value) == "transient failure" &&
-          maxAttempts > 0
-        ) {
-          return Co.Wait(delayBetweenAttemptsInMs).then(() =>
-            Synchronize(
-              p,
-              errorProcessor,
-              maxAttempts - 1,
-              delayBetweenAttemptsInMs,
-            ),
-          );
-        } else {
-          return Co.SetState(
-            Synchronized.Updaters.sync(
-              AsyncState.Updaters.toError(apiResult.value),
-            ),
-          ).then(() => Co.Return("permanent failure"));
+            return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toLoaded(apiResult.value))).then(() => Co.Return("success"));
         }
-      }),
-    ),
-  );
+        else if (errorProcessor(apiResult.value) == "transient failure" &&
+            maxAttempts > 0) {
+            return Co.Wait(delayBetweenAttemptsInMs).then(() => Synchronize(p, errorProcessor, maxAttempts - 1, delayBetweenAttemptsInMs));
+        }
+        else {
+            return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toError(apiResult.value))).then(() => Co.Return("permanent failure"));
+        }
+    })));
 };
-export const SynchronizeWithValueUpdater = (
-  p,
-  errorProcessor = () => "transient failure",
-  maxAttempts = 2,
-  delayBetweenAttemptsInMs = 250,
-) => {
-  const Co = CoTypedFactory();
-  return Co.SetState(
-    Synchronized.Updaters.sync(AsyncState.Updaters.toReloading()),
-  ).then(() =>
-    Co.GetState().then((current) =>
-      Co.Await(() => p(current), id).then((apiResult) => {
+export const SynchronizeWithValueUpdater = (p, errorProcessor = () => "transient failure", maxAttempts = 2, delayBetweenAttemptsInMs = 250) => {
+    const Co = CoTypedFactory();
+    return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toReloading())).then(() => Co.GetState().then((current) => Co.Await(() => p(current), id).then((apiResult) => {
         if (apiResult.kind == "l") {
-          return Co.SetState(
-            Synchronized.Updaters.sync(
-              AsyncState.Updaters.toLoaded(apiResult.value[0]),
-            )
-              .then(Synchronized.Updaters.value(apiResult.value[1]))
-              .then((_) => {
+            return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toLoaded(apiResult.value[0]))
+                .then(Synchronized.Updaters.value(apiResult.value[1]))
+                .then((_) => {
                 return _;
-              }),
-          ).then(() => Co.Return("success"));
-        } else if (
-          errorProcessor(apiResult.value) == "transient failure" &&
-          maxAttempts > 0
-        ) {
-          return Co.Wait(delayBetweenAttemptsInMs).then(() =>
-            SynchronizeWithValueUpdater(
-              p,
-              errorProcessor,
-              maxAttempts - 1,
-              delayBetweenAttemptsInMs,
-            ),
-          );
-        } else {
-          return Co.SetState(
-            Synchronized.Updaters.sync(
-              AsyncState.Updaters.toError(apiResult.value),
-            ),
-          ).then(() => Co.Return("permanent failure"));
+            })).then(() => Co.Return("success"));
+        }
+        else if (errorProcessor(apiResult.value) == "transient failure" &&
+            maxAttempts > 0) {
+            return Co.Wait(delayBetweenAttemptsInMs).then(() => SynchronizeWithValueUpdater(p, errorProcessor, maxAttempts - 1, delayBetweenAttemptsInMs));
+        }
+        else {
+            return Co.SetState(Synchronized.Updaters.sync(AsyncState.Updaters.toError(apiResult.value))).then(() => Co.Return("permanent failure"));
         }
-      }),
-    ),
-  );
+    })));
 };
-//# sourceMappingURL=synchronize.js.map
+//# sourceMappingURL=synchronize.js.map

package/bin/src/async/domains/synchronized/state.d.ts

@@ -1,20 +1,13 @@
 import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
 import { AsyncState } from "../../state";
 export type Synchronized<value, syncResult> = value & {
-  sync: AsyncState<syncResult>;
+    sync: AsyncState<syncResult>;
 };
 export declare const Synchronized: {
-  Default: <value, syncResult>(
-    initialValue: value,
-    sync?: AsyncState<syncResult>,
-  ) => Synchronized<value, syncResult>;
-  Updaters: {
-    sync: <value, syncResult>(
-      _: BasicUpdater<AsyncState<syncResult>>,
-    ) => Updater<Synchronized<value, syncResult>>;
-    value: <value, syncResult>(
-      _: BasicUpdater<value>,
-    ) => Updater<Synchronized<value, syncResult>>;
-  };
+    Default: <value, syncResult>(initialValue: value, sync?: AsyncState<syncResult>) => Synchronized<value, syncResult>;
+    Updaters: {
+        sync: <value, syncResult>(_: BasicUpdater<AsyncState<syncResult>>) => Updater<Synchronized<value, syncResult>>;
+        value: <value, syncResult>(_: BasicUpdater<value>) => Updater<Synchronized<value, syncResult>>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/async/domains/synchronized/state.js

@@ -1,20 +1,10 @@
 import { Updater } from "../../../fun/domains/updater/state";
 import { AsyncState } from "../../state";
 export const Synchronized = {
-  Default: (initialValue, sync) =>
-    Object.assign(Object.assign({}, initialValue), {
-      sync:
-        sync !== null && sync !== void 0 ? sync : AsyncState.Default.unloaded(),
-    }),
-  Updaters: {
-    sync: (_) =>
-      Updater((current) =>
-        Object.assign(Object.assign({}, current), { sync: _(current.sync) }),
-      ),
-    value: (_) =>
-      Updater((current) =>
-        Object.assign(Object.assign({}, current), _(current)),
-      ),
-  },
+    Default: (initialValue, sync) => (Object.assign(Object.assign({}, initialValue), { sync: sync !== null && sync !== void 0 ? sync : AsyncState.Default.unloaded() })),
+    Updaters: {
+        sync: (_) => Updater((current) => (Object.assign(Object.assign({}, current), { sync: _(current.sync) }))),
+        value: (_) => Updater((current) => (Object.assign(Object.assign({}, current), _(current)))),
+    },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/state.d.ts

@@ -1,71 +1,60 @@
 import { Updater } from "../fun/domains/updater/state";
 import { BasicFun, Fun } from "../fun/state";
 export type LoadedAsyncState<a> = {
-  kind: "loaded";
-  value: a;
+    kind: "loaded";
+    value: a;
 };
 export type ReloadingAsyncState<a> = {
-  kind: "reloading";
-  value: a;
+    kind: "reloading";
+    value: a;
 };
 export type FailedReloadAsyncState<a> = {
-  kind: "failed-reload";
-  value: a;
-  error: any;
+    kind: "failed-reload";
+    value: a;
+    error: any;
 };
-export type AsyncState<a> = (
-  | ((
-      | {
-          kind: "unloaded";
-        }
-      | {
-          kind: "loading";
-        }
-      | ReloadingAsyncState<a>
-      | {
-          kind: "error";
-          error: any;
-        }
-    ) & {
-      failedLoadingAttempts: number;
-    })
-  | LoadedAsyncState<a>
-  | FailedReloadAsyncState<a>
-) & {
-  map: <b>(f: BasicFun<a, b>) => AsyncState<b>;
-  getLoadingAttempts: <a>(this: AsyncState<a>) => number;
+export type AsyncState<a> = ((({
+    kind: "unloaded";
+} | {
+    kind: "loading";
+} | ReloadingAsyncState<a> | {
+    kind: "error";
+    error: any;
+}) & {
+    failedLoadingAttempts: number;
+}) | LoadedAsyncState<a> | FailedReloadAsyncState<a>) & {
+    map: <b>(f: BasicFun<a, b>) => AsyncState<b>;
+    getLoadingAttempts: <a>(this: AsyncState<a>) => number;
 };
 export type HasValueAsyncState<a> = AsyncState<a> & {
-  kind: "loaded" | "reloading" | "failed-reload";
+    kind: "loaded" | "reloading" | "failed-reload";
 };
 export type IsLoadingAsyncState<a> = AsyncState<a> & {
-  kind: "loading" | "reloading";
+    kind: "loading" | "reloading";
 };
 export declare const AsyncState: {
-  Default: {
-    unloaded: <a>() => AsyncState<a>;
-    loading: <a>() => AsyncState<a>;
-    reloading: <a>(value: a) => AsyncState<a>;
-    failedReload: <a>(value: a, error?: any) => AsyncState<a>;
-    error: <a>(value?: any) => AsyncState<a>;
-    loaded: <a>(value: a) => AsyncState<a>;
-  };
-  Updaters: {
-    failedLoadingAttempts: <a>(
-      updateAttempts: Updater<number>,
-    ) => Updater<AsyncState<a>>;
-    toUnloaded: <a>() => Updater<AsyncState<a>>;
-    toLoading: <a>() => Updater<AsyncState<a>>;
-    toReloading: <a>() => Updater<AsyncState<a>>;
-    toError: <a>(error?: any) => Updater<AsyncState<a>>;
-    toLoaded: <a>(value: a) => Updater<AsyncState<a>>;
-  };
-  Operations: {
-    map: <a, b>(f: BasicFun<a, b>) => Fun<AsyncState<a>, AsyncState<b>>;
-    status: <a>(_: AsyncState<a>) => a | AsyncState<a>["kind"];
-    hasValue: <a>(_: AsyncState<a>) => _ is HasValueAsyncState<a>;
-    isLoading: <a>(_: AsyncState<a>) => _ is IsLoadingAsyncState<a>;
-    errors: <a>(_: AsyncState<a>) => Array<any>;
-  };
+    Default: {
+        unloaded: <a>() => AsyncState<a>;
+        loading: <a>() => AsyncState<a>;
+        reloading: <a>(value: a) => AsyncState<a>;
+        failedReload: <a>(value: a, error?: any) => AsyncState<a>;
+        error: <a>(value?: any) => AsyncState<a>;
+        loaded: <a>(value: a) => AsyncState<a>;
+    };
+    Updaters: {
+        failedLoadingAttempts: <a>(updateAttempts: Updater<number>) => Updater<AsyncState<a>>;
+        toUnloaded: <a>() => Updater<AsyncState<a>>;
+        toLoading: <a>() => Updater<AsyncState<a>>;
+        toReloading: <a>() => Updater<AsyncState<a>>;
+        toError: <a>(error?: any) => Updater<AsyncState<a>>;
+        toLoaded: <a>(value: a) => Updater<AsyncState<a>>;
+    };
+    Operations: {
+        map: <a, b>(f: BasicFun<a, b>) => Fun<AsyncState<a>, AsyncState<b>>;
+        status: <a>(_: AsyncState<a>) => a | AsyncState<a>["kind"];
+        hasValue: <a>(_: AsyncState<a>) => _ is HasValueAsyncState<a>;
+        isLoading: <a>(_: AsyncState<a>) => _ is IsLoadingAsyncState<a>;
+        errors: <a>(_: AsyncState<a>) => Array<any>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/async/state.js

@@ -1,124 +1,106 @@
 import { Updater } from "../fun/domains/updater/state";
 import { Fun } from "../fun/state";
 function map(f) {
-  return this.kind == "loaded"
-    ? AsyncState.Default.loaded(f(this.value))
-    : this.kind == "unloaded"
-      ? AsyncState.Default.unloaded()
-      : this.kind == "error"
-        ? AsyncState.Default.error()
-        : this.kind == "loading"
-          ? AsyncState.Default.loading()
-          : AsyncState.Default.reloading(f(this.value));
+    return this.kind == "loaded"
+        ? AsyncState.Default.loaded(f(this.value))
+        : this.kind == "unloaded"
+            ? AsyncState.Default.unloaded()
+            : this.kind == "error"
+                ? AsyncState.Default.error()
+                : this.kind == "loading"
+                    ? AsyncState.Default.loading()
+                    : AsyncState.Default.reloading(f(this.value));
 }
 function getLoadingAttempts() {
-  return this.kind == "loaded" || this.kind == "failed-reload"
-    ? 0
-    : this.failedLoadingAttempts;
+    return this.kind == "loaded" || this.kind == "failed-reload"
+        ? 0
+        : this.failedLoadingAttempts;
 }
 export const AsyncState = {
-  Default: {
-    unloaded: () => ({
-      kind: "unloaded",
-      map,
-      getLoadingAttempts,
-      failedLoadingAttempts: 0,
-    }),
-    loading: () => ({
-      kind: "loading",
-      map,
-      getLoadingAttempts,
-      failedLoadingAttempts: 0,
-    }),
-    reloading: (value) => ({
-      kind: "reloading",
-      value,
-      map,
-      getLoadingAttempts,
-      failedLoadingAttempts: 0,
-    }),
-    failedReload: (value, error) => ({
-      kind: "failed-reload",
-      value,
-      error,
-      map,
-      getLoadingAttempts,
-    }),
-    error: (value) => ({
-      kind: "error",
-      map,
-      error: value,
-      getLoadingAttempts,
-      failedLoadingAttempts: 0,
-    }),
-    loaded: (value) => ({
-      kind: "loaded",
-      value,
-      map,
-      getLoadingAttempts,
-    }),
-  },
-  Updaters: {
-    failedLoadingAttempts: (updateAttempts) =>
-      Updater((current) =>
-        current.kind == "loaded" || current.kind == "failed-reload"
-          ? current
-          : Object.assign(Object.assign({}, current), {
-              failedLoadingAttempts: updateAttempts(
-                current.failedLoadingAttempts,
-              ),
-            }),
-      ),
-    toUnloaded: () =>
-      Updater((_) => ({
-        kind: "unloaded",
-        map,
-        getLoadingAttempts,
-        failedLoadingAttempts: 0,
-      })),
-    toLoading: () =>
-      Updater((current) => ({
-        kind: "loading",
-        map,
-        getLoadingAttempts,
-        failedLoadingAttempts: current.getLoadingAttempts(),
-      })),
-    toReloading: () =>
-      Updater((current) =>
-        current.kind == "loaded" || current.kind == "reloading"
-          ? AsyncState.Default.reloading(current.value)
-          : AsyncState.Updaters.toLoading()(current),
-      ),
-    toError: (error) =>
-      Updater((current) =>
-        AsyncState.Operations.hasValue(current)
-          ? {
-              kind: "failed-reload",
-              value: current.value,
-              map,
-              error,
-              getLoadingAttempts,
-              failedLoadingAttempts: current.getLoadingAttempts() + 1,
+    Default: {
+        unloaded: () => ({
+            kind: "unloaded",
+            map,
+            getLoadingAttempts,
+            failedLoadingAttempts: 0,
+        }),
+        loading: () => ({
+            kind: "loading",
+            map,
+            getLoadingAttempts,
+            failedLoadingAttempts: 0,
+        }),
+        reloading: (value) => ({
+            kind: "reloading",
+            value,
+            map,
+            getLoadingAttempts,
+            failedLoadingAttempts: 0,
+        }),
+        failedReload: (value, error) => ({
+            kind: "failed-reload",
+            value,
+            error,
+            map,
+            getLoadingAttempts,
+        }),
+        error: (value) => ({
+            kind: "error",
+            map,
+            error: value,
+            getLoadingAttempts,
+            failedLoadingAttempts: 0,
+        }),
+        loaded: (value) => ({
+            kind: "loaded",
+            value,
+            map,
+            getLoadingAttempts,
+        }),
+    },
+    Updaters: {
+        failedLoadingAttempts: (updateAttempts) => Updater((current) => current.kind == "loaded" || current.kind == "failed-reload"
+            ? current
+            : Object.assign(Object.assign({}, current), { failedLoadingAttempts: updateAttempts(current.failedLoadingAttempts) })),
+        toUnloaded: () => Updater((_) => ({
+            kind: "unloaded",
+            map,
+            getLoadingAttempts,
+            failedLoadingAttempts: 0,
+        })),
+        toLoading: () => Updater((current) => ({
+            kind: "loading",
+            map,
+            getLoadingAttempts,
+            failedLoadingAttempts: current.getLoadingAttempts(),
+        })),
+        toReloading: () => Updater((current) => current.kind == "loaded" || current.kind == "reloading"
+            ? AsyncState.Default.reloading(current.value)
+            : AsyncState.Updaters.toLoading()(current)),
+        toError: (error) => Updater((current) => AsyncState.Operations.hasValue(current)
+            ? {
+                kind: "failed-reload",
+                value: current.value,
+                map,
+                error,
+                getLoadingAttempts,
+                failedLoadingAttempts: current.getLoadingAttempts() + 1,
             }
-          : {
-              kind: "error",
-              map,
-              error,
-              getLoadingAttempts,
-              failedLoadingAttempts: current.getLoadingAttempts() + 1,
-            },
-      ),
-    toLoaded: (value) =>
-      Updater((_) => ({ kind: "loaded", value, map, getLoadingAttempts })),
-  },
-  Operations: {
-    map: (f) => Fun((_) => _.map(f)),
-    status: (_) =>
-      _.kind == "loaded" || _.kind == "reloading" ? _.value : _.kind,
-    hasValue: (_) =>
-      _.kind == "loaded" || _.kind == "reloading" || _.kind == "failed-reload",
-    isLoading: (_) => _.kind == "loading" || _.kind == "reloading",
-    errors: (_) => (_.kind == "error" ? [_.error] : []),
-  },
+            : {
+                kind: "error",
+                map,
+                error,
+                getLoadingAttempts,
+                failedLoadingAttempts: current.getLoadingAttempts() + 1,
+            }),
+        toLoaded: (value) => Updater((_) => ({ kind: "loaded", value, map, getLoadingAttempts })),
+    },
+    Operations: {
+        map: (f) => Fun((_) => _.map(f)),
+        status: (_) => _.kind == "loaded" || _.kind == "reloading" ? _.value : _.kind,
+        hasValue: (_) => _.kind == "loaded" || _.kind == "reloading" || _.kind == "failed-reload",
+        isLoading: (_) => _.kind == "loading" || _.kind == "reloading",
+        errors: (_) => _.kind == "error" ? [_.error] : [],
+    },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/baseEntity/domains/identifiable/state.d.ts

@@ -1,25 +1,21 @@
 import { Map, OrderedMap } from "immutable";
 export type Guid = string;
 export type Identifiable = {
-  Id: Guid;
+    Id: Guid;
 };
 export type SmallIdentifiable = {
-  id: string;
+    id: string;
 };
 export declare const Identifiable: {
-  Operations: {
-    toMap: <T extends Identifiable>(values: Array<T>) => Map<Guid, T>;
-    toOrderedMap: <T extends Identifiable>(
-      values: Array<T>,
-    ) => OrderedMap<Guid, T>;
-  };
+    Operations: {
+        toMap: <T extends Identifiable>(values: Array<T>) => Map<Guid, T>;
+        toOrderedMap: <T extends Identifiable>(values: Array<T>) => OrderedMap<Guid, T>;
+    };
 };
 export declare const SmallIdentifiable: {
-  Operations: {
-    toMap: <T extends SmallIdentifiable>(values: Array<T>) => Map<Guid, T>;
-    toOrderedMap: <T extends SmallIdentifiable>(
-      values: Array<T>,
-    ) => OrderedMap<Guid, T>;
-  };
+    Operations: {
+        toMap: <T extends SmallIdentifiable>(values: Array<T>) => Map<Guid, T>;
+        toOrderedMap: <T extends SmallIdentifiable>(values: Array<T>) => OrderedMap<Guid, T>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/baseEntity/domains/identifiable/state.js

@@ -1,14 +1,14 @@
 import { Map, OrderedMap } from "immutable";
 export const Identifiable = {
-  Operations: {
-    toMap: (values) => Map(values.map((_) => [_.Id, _])),
-    toOrderedMap: (values) => OrderedMap(values.map((_) => [_.Id, _])),
-  },
+    Operations: {
+        toMap: (values) => Map(values.map((_) => [_.Id, _])),
+        toOrderedMap: (values) => OrderedMap(values.map((_) => [_.Id, _])),
+    },
 };
 export const SmallIdentifiable = {
-  Operations: {
-    toMap: (values) => Map(values.map((_) => [_.id, _])),
-    toOrderedMap: (values) => OrderedMap(values.map((_) => [_.id, _])),
-  },
+    Operations: {
+        toMap: (values) => Map(values.map((_) => [_.id, _])),
+        toOrderedMap: (values) => OrderedMap(values.map((_) => [_.id, _])),
+    },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map