@sparted/shared-library 0.0.11 → 0.0.13

package/index.d.ts

@@ -0,0 +1,13 @@
+export * from './array';
+export * from './date';
+export * from './formatting';
+export * from './fp';
+export * from './http';
+export * from './linked-list';
+export * from './math';
+export * from './object';
+export * from './parsing';
+export * from './predicates';
+export * from './promise';
+export * from './string';
+export * from './types';

package/index.js

@@ -1,6 +1,18 @@
 export { arrayToMap } from './array/array-to-map.js';
 export { valuesFromKeys } from './array/get-values-from-keys.js';
+export { MS_DAY, MS_HOUR, MS_MINUTE, MS_SECOND } from './date/constants.js';
+export { formatMinutes } from './date/format-minutes.js';
+export { getTimeDiffAsString } from './date/get-time-diff-as-string.js';
+export { formatNumber } from './formatting/format-number.js';
 export { runWhile } from './fp/run-while.js';
+export { encodeSearchObject, encodeSearchValue } from './http/encode-search-object.js';
+export { fetchWithTimeout } from './http/fetch-with-timeout.js';
+export { createLinkedList } from './linked-list/create-linked-list.js';
+export { clampNumber } from './math/clamp-number.js';
+export { interpolate } from './math/interpolate.js';
+export { assertNumberRange, isNumberInRange } from './math/number-range.js';
+export { randomNumber } from './math/random-number.js';
+export { mergeDeep } from './object/merge-deep.js';
 export { parseBoolean } from './parsing/parse-boolean.js';
 export { createEnumParser } from './parsing/parse-enum.js';
 export { parseNumber } from './parsing/parse-number.js';
@@ -11,5 +23,6 @@ export { isArrayOfPrimitive, isPrimitive } from './predicates/is-primitive.js';
 export { isUndefined } from './predicates/is-undefined.js';
 export { executeOrResolveDefault } from './promise/execute-or-resolve-default.js';
 export { executeWithDelay } from './promise/execute-with-delay.js';
+export { delay } from './promise/delay.js';
 export { replaceInTemplate } from './string/replace-in-template.js';
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/linked-list/apply-diff-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { LinkedList, LinkedListItem } from './type';
+export declare const applyDiffLinkedList: <T extends LinkedListItem>(before: T | null, after: T | null, list: LinkedList<T>) => LinkedList<T>;

package/linked-list/apply-diff-linked-list.js

@@ -0,0 +1,27 @@
+var applyDiffLinkedList = function (before, after, list) {
+    // Delete
+    if (!after && before) {
+        return list.remove(before.id);
+    }
+    // Insert
+    if (!before && after) {
+        return list.insert(after);
+    }
+    // For the following commands, none of the 2 items can be null
+    // We dont use && because checks are already done above, but ts cannot infer that they cannot be null afterwards
+    if (!before || !after) {
+        throw new Error('Cannot have both before & after as null');
+    }
+    if (before.id !== after.id) {
+        throw new Error('Cannot change id of a ListNode');
+    }
+    var listWithPotentialReorder = before.nextId === after.nextId
+        ? list
+        : list
+            .remove(before.id)
+            .insert(after);
+    return listWithPotentialReorder.update(after);
+};
+
+export { applyDiffLinkedList };
+//# sourceMappingURL=apply-diff-linked-list.js.map

package/linked-list/apply-diff-linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-diff-linked-list.js","sources":["../../src/linked-list/apply-diff-linked-list.ts"],"sourcesContent":["import { LinkedList, LinkedListItem, ManipulationConfig } from './type';\n\nexport const applyDiffLinkedList = <T extends LinkedListItem>(\n  before: T | null,\n  after: T | null,\n  list: LinkedList<T>,\n) => {\n  // Delete\n  if (!after && before) {\n    return list.remove(before.id);\n  }\n\n  // Insert\n  if (!before && after) {\n    return list.insert(after);\n  }\n\n  // For the following commands, none of the 2 items can be null\n  // We dont use && because checks are already done above, but ts cannot infer that they cannot be null afterwards\n  if (!before || !after) {\n    throw new Error('Cannot have both before & after as null');\n  }\n\n  if (before.id !== after.id) {\n    throw new Error('Cannot change id of a ListNode');\n  }\n\n  const listWithPotentialReorder = before.nextId === after.nextId\n    ? list\n    : list\n      .remove(before.id)\n      .insert(after);\n\n  return listWithPotentialReorder.update(after);\n};"],"names":[],"mappings":"IAEa,mBAAmB,GAAG,UACjC,MAAgB,EAChB,KAAe,EACf,IAAmB,EAAA;;AAGnB,IAAA,IAAI,CAAC,KAAK,IAAI,MAAM,EAAE;QACpB,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAC/B,KAAA;;AAGD,IAAA,IAAI,CAAC,MAAM,IAAI,KAAK,EAAE;AACpB,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC3B,KAAA;;;AAID,IAAA,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,EAAE;AACrB,QAAA,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;AAC5D,KAAA;AAED,IAAA,IAAI,MAAM,CAAC,EAAE,KAAK,KAAK,CAAC,EAAE,EAAE;AAC1B,QAAA,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;AACnD,KAAA;IAED,IAAM,wBAAwB,GAAG,MAAM,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;AAC7D,UAAE,IAAI;AACN,UAAE,IAAI;AACH,aAAA,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;aACjB,MAAM,CAAC,KAAK,CAAC,CAAC;AAEnB,IAAA,OAAO,wBAAwB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAChD;;;;"}

package/linked-list/create-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { LinkedListItem, LinkedList } from './type';
+export declare const createLinkedList: <T extends LinkedListItem>(headId: string | null, items: Record<string, T>) => LinkedList<T>;

package/linked-list/create-linked-list.js

@@ -0,0 +1,66 @@
+import { reduceLinkedList } from './reduce-linked-list.js';
+import { findLinkedList } from './find-linked-list.js';
+import { whileLinkedList } from './while-linked-list.js';
+import { walkListItemRecord } from './linked-list-utils.js';
+import { removeLinkedList } from './remove-linked-list.js';
+import { insertLinkedList } from './insert-linked-list.js';
+import { getLinkedList } from './get-linked-list.js';
+import { updateLinkedList } from './update-linked-list.js';
+import { applyDiffLinkedList } from './apply-diff-linked-list.js';
+
+var createLinkedList = function (headId, items) {
+    var head = headId ? items[headId] : null;
+    if (head === undefined) {
+        throw new Error('Cannot find the head.');
+    }
+    var list = { headId: headId, items: items };
+    var _a = walkListItemRecord(function (acc, current) {
+        var newCount = acc.count + 1;
+        var isDoubleLinked = current.previousId !== undefined;
+        var incompatibleFormats = acc.isDoubleLinked !== undefined && acc.isDoubleLinked !== isDoubleLinked;
+        if (incompatibleFormats || (isDoubleLinked && current.previousId !== acc.previousId)) {
+            throw new Error('Invalid previous node in the linked list');
+        }
+        return {
+            result: {
+                previousId: current.id,
+                count: newCount,
+                isDoubleLinked: isDoubleLinked,
+            }
+        };
+    }, {
+        initValue: {
+            isDoubleLinked: undefined,
+            count: 0,
+            previousId: null,
+        },
+        startId: headId,
+        items: items,
+    }), isDoubleLinked = _a.isDoubleLinked, count = _a.count;
+    var manipulationConfig = {
+        factory: function (list) { return createLinkedList(list.headId, list.items); },
+        /**
+         * At this point isDoubleLinked cannot be undefined
+         */
+        isDoubleLinkList: isDoubleLinked,
+        list: list,
+    };
+    var linkedList = {
+        head: head,
+        items: items,
+        size: count,
+        isDoubleLinked: isDoubleLinked,
+        reduce: function (cb, initValue) { return reduceLinkedList(cb, initValue, list); },
+        find: function (predicate) { return findLinkedList(predicate, list); },
+        while: function (predicate, startId) { return whileLinkedList(predicate, list, startId); },
+        remove: function (id) { return removeLinkedList(id, manipulationConfig); },
+        insert: function (item) { return insertLinkedList(item, manipulationConfig); },
+        get: function (id) { return getLinkedList(id, list); },
+        update: function (item) { return updateLinkedList(item, manipulationConfig); },
+        applyDiff: function (before, after) { return applyDiffLinkedList(before, after, linkedList); },
+    };
+    return linkedList;
+};
+
+export { createLinkedList };
+//# sourceMappingURL=create-linked-list.js.map

package/linked-list/create-linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-linked-list.js","sources":["../../src/linked-list/create-linked-list.ts"],"sourcesContent":["import { LinkedListItem, LinkedList, ManipulationConfig } from './type';\n\nimport { reduceLinkedList } from './reduce-linked-list';\nimport { findLinkedList } from './find-linked-list';\nimport { whileLinkedList } from './while-linked-list';\nimport { walkListItemRecord } from './linked-list-utils';\nimport { removeLinkedList } from './remove-linked-list';\nimport { insertLinkedList } from './insert-linked-list';\nimport { getLinkedList } from './get-linked-list';\nimport { updateLinkedList } from './update-linked-list';\nimport { applyDiffLinkedList } from './apply-diff-linked-list';\n\ntype LinkedListValidation = {\n  isDoubleLinked?: boolean,\n  previousId: null | string,\n  count: number,\n}\n\nexport const createLinkedList = <T extends LinkedListItem>(headId: string | null, items: Record<string, T>): LinkedList<T> => {\n  const head = headId ? items[headId] : null;\n\n  if (head === undefined) {\n    throw new Error('Cannot find the head.');\n  }\n\n  const list = { headId, items };\n\n  const { isDoubleLinked, count } = walkListItemRecord((acc, current) => {\n    const newCount = acc.count + 1;\n    const isDoubleLinked = current.previousId !== undefined;\n    const incompatibleFormats = acc.isDoubleLinked !== undefined && acc.isDoubleLinked !== isDoubleLinked;\n\n    if (incompatibleFormats || (isDoubleLinked && current.previousId !== acc.previousId)) {\n      throw new Error('Invalid previous node in the linked list');\n    }\n\n    return {\n      result: {\n        previousId: current.id,\n        count: newCount,\n        isDoubleLinked,\n      }\n    }\n  }, {\n    initValue: {\n      isDoubleLinked: undefined,\n      count: 0,\n      previousId: null,\n    } as LinkedListValidation,\n    startId: headId,\n    items,\n  });\n\n  const manipulationConfig: ManipulationConfig<T> = {\n    factory: (list) => createLinkedList(list.headId, list.items),\n    /**\n     * At this point isDoubleLinked cannot be undefined\n     */\n    isDoubleLinkList: isDoubleLinked!,\n    list,\n  };\n\n  const linkedList: LinkedList<T> = {\n    head,\n    items,\n    size: count,\n    isDoubleLinked: isDoubleLinked!,\n    reduce: (cb, initValue) => reduceLinkedList(cb, initValue, list),\n    find: (predicate) => findLinkedList(predicate, list),\n    while: (predicate, startId) => whileLinkedList(predicate, list, startId),\n    remove: (id) => removeLinkedList(id, manipulationConfig),\n    insert: (item) => insertLinkedList(item, manipulationConfig),\n    get: (id) => getLinkedList(id, list),\n    update: (item) => updateLinkedList(item, manipulationConfig),\n    applyDiff: (before, after) => applyDiffLinkedList(before, after, linkedList),\n  };\n\n  return linkedList;\n};"],"names":[],"mappings":"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"}

package/linked-list/find-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { LinkedListItem, ItemPredicate, HeadAndItems } from './type';
+export declare const findLinkedList: <Item extends LinkedListItem>(predicate: ItemPredicate<Item>, list: HeadAndItems<Item>) => Item | null;

package/linked-list/find-linked-list.js

@@ -0,0 +1,25 @@
+import { walkListItemRecord } from './linked-list-utils.js';
+
+var findLinkedList = function (predicate, list) {
+    list.headId;
+    return walkListItemRecord(function (acc, item) {
+        if (predicate(item)) {
+            return {
+                result: item,
+                control: {
+                    stop: true,
+                },
+            };
+        }
+        return {
+            result: acc,
+        };
+    }, {
+        initValue: null,
+        items: list.items,
+        startId: list.headId,
+    });
+};
+
+export { findLinkedList };
+//# sourceMappingURL=find-linked-list.js.map

package/linked-list/find-linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-linked-list.js","sources":["../../src/linked-list/find-linked-list.ts"],"sourcesContent":["import { LinkedListItem, ItemPredicate, HeadAndItems } from './type';\nimport { walkListItemRecord } from './linked-list-utils';\n\nexport const findLinkedList = <Item extends LinkedListItem>(\n  predicate: ItemPredicate<Item>,\n  list: HeadAndItems<Item>,\n): Item | null => {\n  const { headId } = list;\n\n  return walkListItemRecord(\n    (acc, item) => {\n      if (predicate(item)) {\n        return {\n          result: item,\n          control: {\n            stop: true,\n          },\n        };\n      };\n\n      return {\n        result: acc,\n      };\n    }, {\n      initValue: null as Item | null,\n      items: list.items,\n      startId: list.headId,\n    },\n  );\n};\n"],"names":[],"mappings":";;AAGa,IAAA,cAAc,GAAG,UAC5B,SAA8B,EAC9B,IAAwB,EAAA;AAEhB,IAAW,IAAI,CAAA,OAAC;AAExB,IAAA,OAAO,kBAAkB,CACvB,UAAC,GAAG,EAAE,IAAI,EAAA;AACR,QAAA,IAAI,SAAS,CAAC,IAAI,CAAC,EAAE;YACnB,OAAO;AACL,gBAAA,MAAM,EAAE,IAAI;AACZ,gBAAA,OAAO,EAAE;AACP,oBAAA,IAAI,EAAE,IAAI;AACX,iBAAA;aACF,CAAC;AACH,SAAA;QAED,OAAO;AACL,YAAA,MAAM,EAAE,GAAG;SACZ,CAAC;AACJ,KAAC,EAAE;AACD,QAAA,SAAS,EAAE,IAAmB;QAC9B,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,OAAO,EAAE,IAAI,CAAC,MAAM;AACrB,KAAA,CACF,CAAC;AACJ;;;;"}

package/linked-list/get-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { HeadAndItems, LinkedListItem } from './type';
+export declare const getLinkedList: <T extends LinkedListItem>(id: string, list: HeadAndItems<T>) => T | null;

package/linked-list/get-linked-list.js

@@ -0,0 +1,9 @@
+var getLinkedList = function (id, list) {
+    if (list.items[id]) {
+        return list.items[id];
+    }
+    return null;
+};
+
+export { getLinkedList };
+//# sourceMappingURL=get-linked-list.js.map

package/linked-list/get-linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-linked-list.js","sources":["../../src/linked-list/get-linked-list.ts"],"sourcesContent":["import { HeadAndItems, LinkedListItem } from './type';\n\nexport const getLinkedList = <T extends LinkedListItem>(id: string, list: HeadAndItems<T>) => {\n  if (list.items[id]) {\n    return list.items[id];\n  }\n\n  return null;\n}"],"names":[],"mappings":"AAEa,IAAA,aAAa,GAAG,UAA2B,EAAU,EAAE,IAAqB,EAAA;AACvF,IAAA,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;AAClB,QAAA,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AACvB,KAAA;AAED,IAAA,OAAO,IAAI,CAAC;AACd;;;;"}

package/linked-list/index.d.ts

@@ -0,0 +1,2 @@
+export * from './create-linked-list';
+export * from './type';

package/linked-list/index.js

@@ -0,0 +1,2 @@
+export { createLinkedList } from './create-linked-list.js';
+//# sourceMappingURL=index.js.map

package/linked-list/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/linked-list/insert-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { ManipulationConfig, LinkedListItem } from './type';
+export declare const insertLinkedList: <T extends LinkedListItem>(item: T, config: ManipulationConfig<T>) => import("./type").LinkedList<T>;

package/linked-list/insert-linked-list.js

@@ -0,0 +1,30 @@
+import { __assign } from '../_virtual/_tslib.js';
+import { assertItemCompatibility, assertPresence, findPreviousId, assertNewNodePosition } from './linked-list-utils.js';
+
+var insertLinkedList = function (item, config) {
+    var _a, _b, _c;
+    var isDoubleLinkList = config.isDoubleLinkList, list = config.list, factory = config.factory;
+    assertItemCompatibility(item, isDoubleLinkList);
+    assertPresence(item.nextId, list.items);
+    assertPresence(item.previousId, list.items);
+    var previousId = isDoubleLinkList
+        ? item.previousId
+        : findPreviousId(item.nextId, list);
+    assertNewNodePosition(item, {
+        previousId: previousId,
+        list: list,
+    });
+    var newHeadId = item.nextId === list.headId ? item.id : list.headId;
+    var newItems = __assign(__assign(__assign(__assign({}, list.items), (previousId ? (_a = {},
+        _a[previousId] = __assign(__assign({}, list.items[previousId]), { nextId: item.id }),
+        _a) : {})), (isDoubleLinkList && item.nextId ? (_b = {},
+        _b[item.nextId] = __assign(__assign({}, list.items[item.nextId]), (isDoubleLinkList ? { previousId: item.id } : {})),
+        _b) : {})), (_c = {}, _c[item.id] = item, _c));
+    return factory({
+        headId: newHeadId,
+        items: newItems,
+    });
+};
+
+export { insertLinkedList };
+//# sourceMappingURL=insert-linked-list.js.map

package/linked-list/insert-linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-linked-list.js","sources":["../../src/linked-list/insert-linked-list.ts"],"sourcesContent":["import { ManipulationConfig, LinkedListItem } from './type';\n\nimport {\n  findPreviousId,\n  assertItemCompatibility,\n  assertPresence,\n  assertNewNodePosition,\n} from './linked-list-utils';\n\nexport const insertLinkedList = <T extends LinkedListItem>(item: T, config: ManipulationConfig<T>) => {\n  const { isDoubleLinkList, list, factory } = config;\n\n  assertItemCompatibility(item, isDoubleLinkList);\n  assertPresence(item.nextId, list.items);\n  assertPresence(item.previousId, list.items);\n\n  const previousId = isDoubleLinkList\n    ? item.previousId!\n    : findPreviousId(item.nextId, list);\n\n  assertNewNodePosition(item, {\n    previousId,\n    list,\n  });\n\n  const newHeadId = item.nextId === list.headId ? item.id : list.headId;\n  const newItems = {\n    ...list.items,\n    ...(previousId ? {\n      [previousId]: {\n        ...list.items[previousId],\n        nextId: item.id,\n      },\n    } : {}),\n    ...(isDoubleLinkList && item.nextId ? {\n      [item.nextId]: {\n        ...list.items[item.nextId],\n        ...(isDoubleLinkList ? { previousId: item.id } : {}),\n      },\n    } : {}),\n    [item.id]: item,\n  };\n\n  return factory({\n    headId: newHeadId,\n    items: newItems,\n  });\n};\n"],"names":[],"mappings":";;;AASa,IAAA,gBAAgB,GAAG,UAA2B,IAAO,EAAE,MAA6B,EAAA;;AACvF,IAAA,IAAA,gBAAgB,GAAoB,MAAM,CAAA,gBAA1B,EAAE,IAAI,GAAc,MAAM,CAAA,IAApB,EAAE,OAAO,GAAK,MAAM,QAAX,CAAY;AAEnD,IAAA,uBAAuB,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;IAChD,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAE5C,IAAM,UAAU,GAAG,gBAAgB;UAC/B,IAAI,CAAC,UAAW;UAChB,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAEtC,qBAAqB,CAAC,IAAI,EAAE;AAC1B,QAAA,UAAU,EAAA,UAAA;AACV,QAAA,IAAI,EAAA,IAAA;AACL,KAAA,CAAC,CAAC;IAEH,IAAM,SAAS,GAAG,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;IACtE,IAAM,QAAQ,2CACT,IAAI,CAAC,KAAK,CACV,GAAC,UAAU,IAAE,EAAA,GAAA,EAAA;AACd,QAAA,EAAA,CAAC,UAAU,CAAA,GAAA,QAAA,CAAA,QAAA,CAAA,EAAA,EACN,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA,EAAA,EACzB,MAAM,EAAE,IAAI,CAAC,EAAE,EAChB,CAAA;cACC,EAAE,EACH,GAAC,gBAAgB,IAAI,IAAI,CAAC,MAAM,IAAE,EAAA,GAAA,EAAA;AACnC,QAAA,EAAA,CAAC,IAAI,CAAC,MAAM,CAAA,GAAA,QAAA,CAAA,QAAA,CAAA,EAAA,EACP,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IACtB,gBAAgB,GAAG,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,EAAE,EACpD;cACC,EAAE,EACL,GAAA,EAAA,GAAA,EAAA,EAAA,EAAA,CAAA,IAAI,CAAC,EAAE,CAAA,GAAG,IAAI,EAAA,EAAA,EAChB,CAAC;AAEF,IAAA,OAAO,OAAO,CAAC;AACb,QAAA,MAAM,EAAE,SAAS;AACjB,QAAA,KAAK,EAAE,QAAQ;AAChB,KAAA,CAAC,CAAC;AACL;;;;"}

package/linked-list/linked-list-utils.d.ts

@@ -0,0 +1,23 @@
+import { LinkedListItem, HeadAndItems } from './type';
+export declare type WalkConfig<T extends LinkedListItem, Result> = {
+    startId: string | null;
+    items: Record<string, T>;
+    initValue: Result;
+};
+declare type WalkCallbackResult<R> = {
+    result: R;
+    control?: {
+        stop?: boolean;
+    };
+};
+export declare type WalkCallback<Item, Result> = (accumulator: Result, current: Item) => WalkCallbackResult<Result>;
+export declare const walkListItemRecord: <T extends LinkedListItem, Result>(callback: WalkCallback<T, Result>, config: WalkConfig<T, Result>) => Result;
+export declare const findPreviousId: <T extends LinkedListItem>(id: string | null, list: HeadAndItems<T>) => string | null;
+export declare const assertItemCompatibility: <T extends LinkedListItem>(item: T, isDoubleLinkList: boolean) => void;
+export declare const assertPresence: (id: string | null | undefined, items: Record<string, unknown>) => void;
+declare type PositionAssertionConfig = {
+    previousId: string | null;
+    list: HeadAndItems<LinkedListItem>;
+};
+export declare const assertNewNodePosition: <T extends LinkedListItem>(item: T, config: PositionAssertionConfig) => void;
+export {};

package/linked-list/linked-list-utils.js

@@ -0,0 +1,97 @@
+import { runWhile } from '../fp/run-while.js';
+
+var walkListItemRecord = function (callback, config) {
+    var _a;
+    var items = config.items, startId = config.startId, initValue = config.initValue;
+    var visited = new Set();
+    var totalNodes = Object.keys(items).length;
+    var _b = runWhile({
+        iterationLimit: totalNodes + 1,
+        initialValue: {
+            currentId: startId,
+            accumulator: initValue,
+            control: {
+                stop: false,
+            },
+        },
+        predicate: function (_a) {
+            var control = _a.control, currentId = _a.currentId;
+            var stop = control === null || control === void 0 ? void 0 : control.stop;
+            var forcedStop = stop === undefined ? false : stop;
+            /**
+             * Stop early or when the end is reached
+             */
+            return !forcedStop && currentId !== null;
+        },
+        callback: function (current) {
+            if (visited.has(current.currentId)) {
+                throw new Error('Infinite loop found');
+            }
+            visited.add(current.currentId);
+            var currentItem = items[current.currentId];
+            if (!currentItem) {
+                throw new Error('Cul de sac detected');
+            }
+            var _a = callback(current.accumulator, currentItem), result = _a.result, control = _a.control;
+            return {
+                accumulator: result,
+                currentId: currentItem.nextId,
+                control: control,
+            };
+        },
+    }), iterationCount = _b.iterationCount, result = _b.result;
+    /**
+     * When force stopping the walk, we will always have unvisited
+     * nodes, so we skip this check.
+     */
+    if (iterationCount !== totalNodes && ((_a = result.control) === null || _a === void 0 ? void 0 : _a.stop) !== true) {
+        throw new Error('Isolated nodes found');
+    }
+    return result.accumulator;
+};
+var findPreviousId = function (id, list) {
+    if (id === list.headId) {
+        return null;
+    }
+    return walkListItemRecord(function (acc, current) {
+        if (current.nextId === id) {
+            return {
+                result: current.id,
+                control: {
+                    stop: true,
+                },
+            };
+        }
+        return {
+            result: acc,
+        };
+    }, {
+        initValue: null,
+        startId: list.headId,
+        items: list.items,
+    });
+};
+var assertItemCompatibility = function (item, isDoubleLinkList) {
+    var incompatibleWithDoubleLinks = item.previousId === undefined && isDoubleLinkList;
+    var incompatibleWithSingleLink = item.previousId !== undefined && !isDoubleLinkList;
+    if (incompatibleWithDoubleLinks || incompatibleWithSingleLink) {
+        throw new Error("Node is incompatible with the list (id: ".concat(item.id, ")"));
+    }
+};
+var assertPresence = function (id, items) {
+    if (id && !items[id]) {
+        throw new Error("Node not found in the list (id: ".concat(id, ")"));
+    }
+};
+var assertNewNodePosition = function (item, config) {
+    var previousId = config.previousId, list = config.list;
+    var insertionMiddleError = previousId && list.items[previousId].nextId !== item.nextId;
+    var insertionTailError = previousId && item.nextId === null && list.items[previousId].nextId !== null;
+    var insertionHeadError = previousId === null && item.nextId !== list.headId;
+    if (insertionMiddleError || insertionTailError || insertionHeadError) {
+        throw new Error("Invalid position for given node (id: ".concat(item.id, ")"));
+    }
+};
+
+export { assertItemCompatibility, assertNewNodePosition, assertPresence, findPreviousId, walkListItemRecord };
+//# sourceMappingURL=linked-list-utils.js.map

package/linked-list/linked-list-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linked-list-utils.js","sources":["../../src/linked-list/linked-list-utils.ts"],"sourcesContent":["import { runWhile } from '../fp';\nimport { LinkedListItem, HeadAndItems} from './type';\n\nexport type WalkConfig<T extends LinkedListItem, Result> = {\n  startId: string | null,\n  items: Record<string, T>,\n  initValue: Result,\n}\n\ntype WalkCallbackResult<R> = {\n  result: R,\n  control?: {\n    stop?: boolean,\n  },\n};\n\nexport type WalkCallback<Item, Result> = (accumulator: Result, current: Item) => WalkCallbackResult<Result>;\n\ntype RunWhileValue<T> = {\n  currentId: string | null,\n  accumulator: T,\n  control: WalkCallbackResult<any>['control'],\n}\n\nexport const walkListItemRecord = <T extends LinkedListItem, Result>(\n  callback: WalkCallback<T, Result>,\n  config: WalkConfig<T, Result>,\n) => {\n  const { items, startId, initValue } = config;\n  const visited = new Set();\n  const totalNodes = Object.keys(items).length;\n\n  const { iterationCount, result } = runWhile({\n    iterationLimit: totalNodes + 1,\n    initialValue: {\n      currentId: startId, \n      accumulator: initValue,\n      control: {\n        stop: false,\n      },\n    } as RunWhileValue<Result>,\n    predicate: ({ control, currentId }) => {\n      const stop = control?.stop;\n      const forcedStop = stop === undefined ? false : stop;\n\n      /**\n       * Stop early or when the end is reached\n       */\n      return !forcedStop && currentId !== null;\n    },\n    callback: (current) => {\n      if (visited.has(current.currentId)) {\n        throw new Error('Infinite loop found');\n      }\n\n      visited.add(current.currentId);\n\n      const currentItem = items[current.currentId!];\n\n      if (!currentItem) {\n        throw new Error('Cul de sac detected');\n      }\n\n      const { result, control } = callback(current.accumulator, currentItem);\n\n      return {\n        accumulator: result,\n        currentId: currentItem.nextId,\n        control: control,\n      };\n    },\n  });\n\n  /**\n   * When force stopping the walk, we will always have unvisited\n   * nodes, so we skip this check.\n   */\n  if (iterationCount !== totalNodes && result.control?.stop !== true) {\n    throw new Error('Isolated nodes found');\n  }\n\n  return result.accumulator;\n};\n\nexport const findPreviousId = <T extends LinkedListItem>(id: string | null, list: HeadAndItems<T>) => {\n  if (id === list.headId) {\n    return null;\n  }\n\n  return walkListItemRecord(\n    (acc, current) => {\n      if (current.nextId === id) {\n        return {\n          result: current.id,\n          control: {\n            stop: true,\n          },\n        };\n      }\n\n      return {\n        result: acc,\n      }\n    },\n    {\n      initValue: null as null | string,\n      startId: list.headId,\n      items: list.items,\n    }\n  )\n};\n\nexport const assertItemCompatibility = <T extends LinkedListItem>(item: T, isDoubleLinkList: boolean) => {\n  const incompatibleWithDoubleLinks = item.previousId === undefined && isDoubleLinkList;\n  const incompatibleWithSingleLink = item.previousId !== undefined && !isDoubleLinkList;\n\n  if (incompatibleWithDoubleLinks || incompatibleWithSingleLink) {\n    throw new Error(`Node is incompatible with the list (id: ${item.id})`);\n  }\n}\n\nexport const assertPresence = (id: string | null | undefined, items: Record<string, unknown>) => {\n  if (id && !items[id]) {\n    throw new Error(`Node not found in the list (id: ${id})`);\n  }\n}\n\ntype PositionAssertionConfig = {\n  previousId: string | null,\n  list: HeadAndItems<LinkedListItem>,\n};\n\nexport const assertNewNodePosition = <T extends LinkedListItem>(item: T, config: PositionAssertionConfig) => {\n  const { previousId, list } = config;\n\n  const insertionMiddleError = previousId && list.items[previousId].nextId !== item.nextId;\n  const insertionTailError = previousId && item.nextId === null && list.items[previousId].nextId !== null;\n  const insertionHeadError = previousId === null && item.nextId !== list.headId;\n\n  if (insertionMiddleError || insertionTailError || insertionHeadError) {\n    throw new Error(`Invalid position for given node (id: ${item.id})`);\n  }\n}"],"names":[],"mappings":"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"}

package/linked-list/reduce-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { ReduceCallback, LinkedListItem, HeadAndItems } from './type';
+export declare const reduceLinkedList: <Item extends LinkedListItem, Result>(cb: ReduceCallback<Item, Result>, initValue: Result, list: HeadAndItems<Item>) => Result;

package/linked-list/reduce-linked-list.js

@@ -0,0 +1,17 @@
+import { walkListItemRecord } from './linked-list-utils.js';
+
+var reduceLinkedList = function (cb, initValue, list) {
+    var items = list.items, headId = list.headId;
+    return walkListItemRecord(function (acc, current) {
+        return {
+            result: cb(acc, current),
+        };
+    }, {
+        startId: headId,
+        items: items,
+        initValue: initValue,
+    });
+};
+
+export { reduceLinkedList };
+//# sourceMappingURL=reduce-linked-list.js.map

package/linked-list/reduce-linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce-linked-list.js","sources":["../../src/linked-list/reduce-linked-list.ts"],"sourcesContent":["import { ReduceCallback, LinkedListItem, HeadAndItems } from './type';\nimport { walkListItemRecord } from './linked-list-utils';\n\nexport const reduceLinkedList = <Item extends LinkedListItem, Result>(\n  cb: ReduceCallback<Item, Result>,\n  initValue: Result,\n  list: HeadAndItems<Item>,\n): Result => {\n  const { items, headId } = list;\n\n  return walkListItemRecord((acc, current) => {\n    return {\n      result: cb(acc, current),\n    };\n  }, {\n    startId: headId,\n    items,\n    initValue,\n  });\n};\n"],"names":[],"mappings":";;IAGa,gBAAgB,GAAG,UAC9B,EAAgC,EAChC,SAAiB,EACjB,IAAwB,EAAA;IAEhB,IAAA,KAAK,GAAa,IAAI,CAAA,KAAjB,EAAE,MAAM,GAAK,IAAI,CAAA,MAAT,CAAU;AAE/B,IAAA,OAAO,kBAAkB,CAAC,UAAC,GAAG,EAAE,OAAO,EAAA;QACrC,OAAO;AACL,YAAA,MAAM,EAAE,EAAE,CAAC,GAAG,EAAE,OAAO,CAAC;SACzB,CAAC;AACJ,KAAC,EAAE;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,KAAK,EAAA,KAAA;AACL,QAAA,SAAS,EAAA,SAAA;AACV,KAAA,CAAC,CAAC;AACL;;;;"}

package/linked-list/remove-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { ManipulationConfig, LinkedListItem } from './type';
+export declare const removeLinkedList: <T extends LinkedListItem>(id: string, config: ManipulationConfig<T>) => import("./type").LinkedList<T>;

package/linked-list/remove-linked-list.js

@@ -0,0 +1,25 @@
+import { __rest, __assign } from '../_virtual/_tslib.js';
+import { assertPresence, findPreviousId } from './linked-list-utils.js';
+
+var removeLinkedList = function (id, config) {
+    var _a, _b;
+    var isDoubleLinkList = config.isDoubleLinkList, list = config.list, factory = config.factory;
+    var _c = list.items, _d = id, itemToDelete = _c[_d], otherItems = __rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
+    assertPresence(id, list.items);
+    var previousId = isDoubleLinkList
+        ? itemToDelete.previousId
+        : findPreviousId(id, list);
+    var newHeadId = previousId === null ? itemToDelete.nextId : list.headId;
+    var newItems = __assign(__assign(__assign({}, otherItems), (previousId ? (_a = {},
+        _a[previousId] = __assign(__assign({}, otherItems[previousId]), { nextId: itemToDelete.nextId }),
+        _a) : {})), (isDoubleLinkList && itemToDelete.nextId ? (_b = {},
+        _b[itemToDelete.nextId] = __assign(__assign({}, otherItems[itemToDelete.nextId]), (isDoubleLinkList ? { previousId: previousId } : {})),
+        _b) : {}));
+    return factory({
+        headId: newHeadId,
+        items: newItems,
+    });
+};
+
+export { removeLinkedList };
+//# sourceMappingURL=remove-linked-list.js.map

package/linked-list/remove-linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-linked-list.js","sources":["../../src/linked-list/remove-linked-list.ts"],"sourcesContent":["import { ManipulationConfig, LinkedListItem } from './type';\nimport { assertPresence, findPreviousId } from './linked-list-utils';\n\nexport const removeLinkedList = <T extends LinkedListItem>(id: string, config: ManipulationConfig<T>) => {\n  const { isDoubleLinkList, list, factory } = config;\n  const { [id]: itemToDelete, ...otherItems } = list.items;\n\n  assertPresence(id, list.items);\n\n  const previousId = isDoubleLinkList\n    ? itemToDelete.previousId!\n    : findPreviousId(id, list);\n\n  const newHeadId = previousId === null ? itemToDelete.nextId : list.headId;\n  const newItems = {\n    ...otherItems,\n    ...(previousId ? {\n      [previousId]: {\n        ...otherItems[previousId],\n        nextId: itemToDelete.nextId,\n      },\n    } : {}),\n    ...(isDoubleLinkList && itemToDelete.nextId ? {\n      [itemToDelete.nextId]: {\n        ...otherItems[itemToDelete.nextId],\n        ...(isDoubleLinkList ? { previousId } : {}),\n      }\n    } : {}),\n  };\n\n  return factory({\n    headId: newHeadId,\n    items: newItems,\n  });\n};"],"names":[],"mappings":";;;AAGa,IAAA,gBAAgB,GAAG,UAA2B,EAAU,EAAE,MAA6B,EAAA;;AAC1F,IAAA,IAAA,gBAAgB,GAAoB,MAAM,CAAA,gBAA1B,EAAE,IAAI,GAAc,MAAM,CAAA,IAApB,EAAE,OAAO,GAAK,MAAM,QAAX,CAAY;AACnD,IAAA,IAA8C,EAAA,GAAA,IAAI,CAAC,KAAK,EAAhD,EAAC,GAAA,EAAG,EAAE,YAAY,SAAA,EAAK,UAAU,GAAnC,MAAA,CAAA,EAAA,EAAA,CAAA,OAAA,EAAA,KAAA,QAAA,GAAA,EAAA,GAAA,EAAA,GAAA,EAAA,CAAqC,CAAa,CAAC;AAEzD,IAAA,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAE/B,IAAM,UAAU,GAAG,gBAAgB;UAC/B,YAAY,CAAC,UAAW;AAC1B,UAAE,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;AAE7B,IAAA,IAAM,SAAS,GAAG,UAAU,KAAK,IAAI,GAAG,YAAY,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;AAC1E,IAAA,IAAM,QAAQ,GACT,QAAA,CAAA,QAAA,CAAA,QAAA,CAAA,EAAA,EAAA,UAAU,IACT,UAAU,IAAE,EAAA,GAAA,EAAA;AACd,QAAA,EAAA,CAAC,UAAU,CAAA,GAAA,QAAA,CAAA,QAAA,CAAA,EAAA,EACN,UAAU,CAAC,UAAU,CAAC,CACzB,EAAA,EAAA,MAAM,EAAE,YAAY,CAAC,MAAM,EAC5B,CAAA;cACC,EAAE,EACH,GAAC,gBAAgB,IAAI,YAAY,CAAC,MAAM,IAAE,EAAA,GAAA,EAAA;QAC3C,EAAC,CAAA,YAAY,CAAC,MAAM,CACf,GAAA,QAAA,CAAA,QAAA,CAAA,EAAA,EAAA,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAC/B,GAAC,gBAAgB,GAAG,EAAE,UAAU,EAAA,UAAA,EAAE,GAAG,EAAE,EAC3C;AACD,QAAA,EAAA,IAAE,EAAE,EACP,CAAC;AAEF,IAAA,OAAO,OAAO,CAAC;AACb,QAAA,MAAM,EAAE,SAAS;AACjB,QAAA,KAAK,EAAE,QAAQ;AAChB,KAAA,CAAC,CAAC;AACL;;;;"}

package/linked-list/type.d.ts

@@ -0,0 +1,34 @@
+export declare type LinkedListItem = {
+    id: string;
+    nextId: string | null;
+    previousId?: string | null;
+};
+export declare type HeadAndItems<T extends LinkedListItem> = {
+    headId: string | null;
+    items: {
+        [id: string]: T;
+    };
+};
+export declare type ReduceCallback<Item, Result> = (accumulator: Result, current: Item) => Result;
+export declare type ItemPredicate<Item> = (item: Item) => boolean;
+export declare type ManipulationConfig<T extends LinkedListItem> = {
+    isDoubleLinkList: boolean;
+    list: HeadAndItems<T>;
+    factory: (list: HeadAndItems<T>) => LinkedList<T>;
+};
+export declare type LinkedList<T extends LinkedListItem> = {
+    readonly head: T | null;
+    readonly items: {
+        [id: string]: T;
+    };
+    readonly size: number;
+    readonly isDoubleLinked: boolean;
+    readonly reduce: <Result>(cb: ReduceCallback<T, Result>, init: Result) => Result;
+    readonly find: (predicate: ItemPredicate<T>) => T | null;
+    readonly while: (predicate: ItemPredicate<T>, startId?: string) => string[];
+    readonly remove: (id: string) => LinkedList<T>;
+    readonly insert: (item: T) => LinkedList<T>;
+    readonly get: (id: string) => T | null;
+    readonly update: (item: T) => LinkedList<T>;
+    readonly applyDiff: (before: T | null, after: T | null) => LinkedList<T>;
+};

package/linked-list/update-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { ManipulationConfig, LinkedListItem } from './type';
+export declare const updateLinkedList: <T extends LinkedListItem>(item: T, config: ManipulationConfig<T>) => import("./type").LinkedList<T>;

package/linked-list/update-linked-list.js

@@ -0,0 +1,21 @@
+import { __rest, __assign } from '../_virtual/_tslib.js';
+import { assertPresence } from './linked-list-utils.js';
+
+var updateLinkedList = function (item, config) {
+    var _a;
+    var list = config.list, factory = config.factory;
+    assertPresence(item.id, list.items);
+    /**
+     * This method should not update any ids.
+     */
+    item.nextId; item.previousId; item.id; var updatableProperties = __rest(item, ["nextId", "previousId", "id"]);
+    var currentItem = list.items[item.id];
+    var newItems = __assign(__assign({}, list.items), (_a = {}, _a[item.id] = __assign(__assign({}, currentItem), updatableProperties), _a));
+    return factory({
+        headId: list.headId,
+        items: newItems,
+    });
+};
+
+export { updateLinkedList };
+//# sourceMappingURL=update-linked-list.js.map

package/linked-list/update-linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-linked-list.js","sources":["../../src/linked-list/update-linked-list.ts"],"sourcesContent":["import { ManipulationConfig, LinkedListItem } from './type';\nimport { assertPresence } from './linked-list-utils';\n\nexport const updateLinkedList = <T extends LinkedListItem>(item: T,  config: ManipulationConfig<T>) => {\n  const { list, factory } = config;\n\n  assertPresence(item.id, list.items);\n\n  /**\n   * This method should not update any ids.\n   */\n  const { nextId, previousId, id, ...updatableProperties } = item;\n  const currentItem = list.items[item.id];\n\n  const newItems = {\n    ...list.items,\n    [item.id]: {\n      ...currentItem,\n      ...updatableProperties,\n    },\n  };\n\n  return factory({\n    headId: list.headId,\n    items: newItems,\n  });\n};\n"],"names":[],"mappings":";;;AAGa,IAAA,gBAAgB,GAAG,UAA2B,IAAO,EAAG,MAA6B,EAAA;;IACxF,IAAA,IAAI,GAAc,MAAM,CAAA,IAApB,EAAE,OAAO,GAAK,MAAM,CAAA,OAAX,CAAY;IAEjC,cAAc,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;AAEpC;;AAEG;IACwD,IAAI,CAAA,MAAjD,EAA6C,IAAI,CAArC,UAAA,CAAA,CAAiC,IAAI,GAAjC,CAAK,KAAA,mBAAmB,UAAK,IAAI,EAAzD,CAAkD,QAAA,EAAA,YAAA,EAAA,IAAA,CAAA,EAAQ;IAChE,IAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAExC,IAAA,IAAM,QAAQ,GAAA,QAAA,CAAA,QAAA,CAAA,EAAA,EACT,IAAI,CAAC,KAAK,CACZ,GAAA,EAAA,GAAA,EAAA,EAAA,EAAA,CAAA,IAAI,CAAC,EAAE,CACH,GAAA,QAAA,CAAA,QAAA,CAAA,EAAA,EAAA,WAAW,CACX,EAAA,mBAAmB,OAEzB,CAAC;AAEF,IAAA,OAAO,OAAO,CAAC;QACb,MAAM,EAAE,IAAI,CAAC,MAAM;AACnB,QAAA,KAAK,EAAE,QAAQ;AAChB,KAAA,CAAC,CAAC;AACL;;;;"}

package/linked-list/walk-list-item-record.d.ts

@@ -0,0 +1,15 @@
+import { LinkedListItem } from './type';
+export declare type WalkConfig<T extends LinkedListItem, Result> = {
+    startId: string | null;
+    items: Record<string, T>;
+    initValue: Result;
+};
+declare type WalkCallbackResult<R> = {
+    result: R;
+    control?: {
+        stop?: boolean;
+    };
+};
+export declare type WalkCallback<Item, Result> = (accumulator: Result, current: Item) => WalkCallbackResult<Result>;
+export declare const walkListItemRecord: <T extends LinkedListItem, Result>(callback: WalkCallback<T, Result>, config: WalkConfig<T, Result>) => Result;
+export {};

package/linked-list/while-linked-list.d.ts

@@ -0,0 +1,2 @@
+import { LinkedListItem, ItemPredicate, HeadAndItems } from './type';
+export declare const whileLinkedList: <Item extends LinkedListItem>(predicate: ItemPredicate<Item>, list: HeadAndItems<Item>, startId?: string) => string[];

package/linked-list/while-linked-list.js

@@ -0,0 +1,29 @@
+import { __spreadArray } from '../_virtual/_tslib.js';
+import { walkListItemRecord } from './linked-list-utils.js';
+
+var whileLinkedList = function (predicate, list, startId) {
+    if (startId && !list.items[startId]) {
+        throw new Error('Cannot start from a node that does not exist');
+    }
+    return walkListItemRecord(function (acc, item) {
+        var itemMatched = predicate(item);
+        if (itemMatched) {
+            return {
+                result: __spreadArray(__spreadArray([], acc, true), [item.id], false),
+            };
+        }
+        return {
+            result: acc,
+            control: {
+                stop: true,
+            },
+        };
+    }, {
+        initValue: [],
+        startId: startId || list.headId,
+        items: list.items,
+    });
+};
+
+export { whileLinkedList };
+//# sourceMappingURL=while-linked-list.js.map

package/linked-list/while-linked-list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"while-linked-list.js","sources":["../../src/linked-list/while-linked-list.ts"],"sourcesContent":["\n\nimport { LinkedListItem, ItemPredicate, HeadAndItems } from './type';\nimport { walkListItemRecord } from './linked-list-utils';\n\nexport const whileLinkedList = <Item extends LinkedListItem>(\n  predicate: ItemPredicate<Item>,\n  list: HeadAndItems<Item>,\n  startId?: string,\n): string[] => {\n  if (startId && !list.items[startId]) {\n    throw new Error('Cannot start from a node that does not exist');\n  }\n\n  return walkListItemRecord(\n    (acc, item) => {\n      const itemMatched = predicate(item);\n\n      if (itemMatched) {\n        return {\n          result: [...acc, item.id],\n        };\n      }\n\n      return {\n        result: acc,\n        control: {\n          stop: true,\n        },\n      };\n    }, {\n      initValue: [] as string[],\n      startId: startId || list.headId,\n      items: list.items,\n    },\n  );\n};\n"],"names":[],"mappings":";;;IAKa,eAAe,GAAG,UAC7B,SAA8B,EAC9B,IAAwB,EACxB,OAAgB,EAAA;IAEhB,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;AACnC,QAAA,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;AACjE,KAAA;AAED,IAAA,OAAO,kBAAkB,CACvB,UAAC,GAAG,EAAE,IAAI,EAAA;AACR,QAAA,IAAM,WAAW,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;AAEpC,QAAA,IAAI,WAAW,EAAE;YACf,OAAO;AACL,gBAAA,MAAM,kCAAM,GAAG,EAAA,IAAA,CAAA,EAAA,CAAE,IAAI,CAAC,EAAE,CAAC,EAAA,KAAA,CAAA;aAC1B,CAAC;AACH,SAAA;QAED,OAAO;AACL,YAAA,MAAM,EAAE,GAAG;AACX,YAAA,OAAO,EAAE;AACP,gBAAA,IAAI,EAAE,IAAI;AACX,aAAA;SACF,CAAC;AACJ,KAAC,EAAE;AACD,QAAA,SAAS,EAAE,EAAc;AACzB,QAAA,OAAO,EAAE,OAAO,IAAI,IAAI,CAAC,MAAM;QAC/B,KAAK,EAAE,IAAI,CAAC,KAAK;AAClB,KAAA,CACF,CAAC;AACJ;;;;"}

package/math/clamp-number.d.ts

@@ -0,0 +1,2 @@
+import type { NumberRange } from './number-range';
+export declare const clampNumber: (num: number, { min, max }: NumberRange) => number;

package/math/clamp-number.js

@@ -0,0 +1,10 @@
+import { assertNumberRange } from './number-range.js';
+
+var clampNumber = function (num, _a) {
+    var min = _a.min, max = _a.max;
+    assertNumberRange({ min: min, max: max });
+    return Math.min(Math.max(num, min), max);
+};
+
+export { clampNumber };
+//# sourceMappingURL=clamp-number.js.map