ballerina-core 1.0.256 → 1.0.258

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

@@ -1,7 +1,10 @@
 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,7 +1,12 @@
 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,12 +1,23 @@
 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,38 +2,90 @@ 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"));
+          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"));
         }
-        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,13 +1,20 @@
 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,10 +1,20 @@
 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,60 +1,71 @@
 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,106 +1,124 @@
 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,
-            }
-            : {
-                kind: "error",
-                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,
+              ),
             }),
-        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] : [],
-    },
+      ),
+    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] : []),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,21 +1,25 @@
 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