@cognite/underscore 1.0.0

package/README.md

@@ -0,0 +1,40 @@
+# Lodashy
+
+> [!WARNING]
+> This package is developed and published for Cognite's internal use. It is made publicly available on npm as a
+> side effect of our internal tooling, but no support, stability, or continued availability is guaranteed for
+> external users. Cognite makes no warranty regarding this package and accepts no liability for any security
+> vulnerabilities, defects, or issues arising from its use, by internal or external consumers.
+
+A collection of useful plain Typescript utility functions.
+
+## Functions
+
+See the collection of functions [here](./docs/modules.md).
+
+## Importing
+
+The library has two modules. Non-React functions is imported the following way:
+```ts
+import { someFunction } from '@cognite/underscore';
+```
+
+But React functions are imported the following way:
+```ts
+import { someFunction } from '@cognite/underscore/react';
+```
+
+## Example
+
+```ts
+import { getNumbersBetween } from '@cognite/underscore';
+
+const numbers = getNumbersBetween(1, 5);
+for (const num of numbers) {
+  console.log(num); // 1, 2, 3, 4
+}
+```
+
+## Update documentation
+
+To update the documentation, please run `pnpm nx docs underscore`.

package/dist/arrays.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Inserts an element at a specific index in an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ * @param {number} index - The index at which to insert the element.
+ * @param {T} item - The element to insert.
+ */
+export declare function insertAt<T>(array: T[], index: number, item: T): void;
+/**
+ * Removes an element from an array, but only removed the first occurrence.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ * @param {T} item - The element to remove.
+ */
+export declare function remove<T>(array: T[], item: T): void;
+/**
+ * Removes an element by the index from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ * @param {number} index - The index of the element to remove.
+ */
+export declare function removeAt<T>(array: T[], index: number): void;
+/**
+ * Swaps two elements in an array at index `i` and `j`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ * @param {number} i - The index of the first element.
+ * @param {number} j - The index of the second element.
+ */
+export declare function swap<T>(array: T[], i: number, j: number): void;
+/**
+ * Shuffles the elements of the given array using the Fisher-Yates algorithm.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array.
+ */
+export declare function shuffle<T>(array: T[]): void;

package/dist/arrays.js

@@ -0,0 +1,23 @@
+import { randomInteger as e } from "./random.js";
+//#region libs/shared/underscore/src/arrays.ts
+function t(e, t, n) {
+	e.splice(t, 0, n);
+}
+function n(e, t) {
+	let n = e.indexOf(t);
+	n !== -1 && r(e, n);
+}
+function r(e, t) {
+	e.splice(t, 1);
+}
+function i(e, t, n) {
+	[e[t], e[n]] = [e[n], e[t]];
+}
+function a(t) {
+	for (let n = t.length - 1; n >= 0; n--) {
+		let r = e(0, n + 1);
+		i(t, n, r);
+	}
+}
+//#endregion
+export { t as insertAt, n as remove, r as removeAt, a as shuffle, i as swap };

package/dist/assert.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whatever gets passed into the condition parameter must be true if the assert returns. That means that for the rest of the scope, that condition must be truthy from the perspective of the type checker.
+ * Adapted from {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions}
+ *
+ * @param condition - A condition which is guaranteed to be true for the rest of the calling scope after this function returns.
+ * @param msg - The message which should be included in the error given that the condition fails.
+ */
+export declare function assert(condition: unknown, msg?: string): asserts condition;

package/dist/assert.js

@@ -0,0 +1,6 @@
+//#region libs/shared/underscore/src/assert.ts
+function e(e, t) {
+	if (!e) throw Error(t);
+}
+//#endregion
+export { e as assert };

package/dist/brand.d.ts

@@ -0,0 +1,42 @@
+declare const brand: unique symbol;
+/**
+ * Adds a compile-time-only "brand" to a base type, producing a nominal type.
+ * TypeScript's structural typing normally treats any two types with the same shape as
+ * interchangeable, so a `UserId` and an `OrderId` that are both `string` can be passed to each
+ * other's functions by mistake.
+ * `Brand` closes that hole by attaching a unique, unused property to the type, so values of
+ * different brands are no longer assignable to one another even though they share a base type.
+ * The branded property does not exist at runtime — it is erased during compilation and only
+ * affects type checking.
+ *
+ * Declare a custom branded type by aliasing `Brand` with a base type and a unique name:
+ * ```ts
+ * type UserId = Brand<string, 'UserId'>;
+ * type OrderId = Brand<string, 'OrderId'>;
+ * ```
+ *
+ * Because there is no runtime representation, values must be converted into a branded type with
+ * a type assertion, typically inside a small constructor function that documents and centralizes
+ * the conversion:
+ * ```ts
+ * function toUserId(id: string): UserId {
+ *   return id as UserId;
+ * }
+ * ```
+ *
+ * Once created, a branded value can still be used wherever the base type is expected...
+ * ```ts
+ * function logId(id: string) {}
+ * logId(toUserId('abc')); // OK, UserId is a string
+ * ```
+ * ...but the reverse requires an explicit conversion, and brands are not interchangeable:
+ * ```ts
+ * function getUser(id: UserId) {}
+ * getUser('abc');             // Error, plain string is not a UserId
+ * getUser(toOrderId('abc'));  // Error, OrderId is not a UserId
+ * ```
+ */
+export type Brand<Base, Name extends string> = Base & {
+    readonly [brand]: Name;
+};
+export {};

package/dist/chunk-and-process-in-parallel.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Options for {@link chunkAndProcessInParallel}.
+ */
+export interface ChunkAndProcessOptions {
+    /**
+     * Maximum number of chunks to process in parallel.
+     * @default 10
+     */
+    numWorkers?: number;
+}
+/**
+ * Error thrown when {@link chunkAndProcessInParallel} fails partway through processing.
+ *
+ * This error provides detailed information about which items were successfully processed,
+ * which items failed, and which items were never attempted.
+ *
+ * @template T - The type of input elements.
+ */
+export declare class PartialExecutionError<T, U> extends Error {
+    /**
+     * The underlying error that caused the failure.
+     */
+    readonly reason: Error;
+    /**
+     * Input items from chunks that were successfully processed before the error occurred.
+     */
+    readonly succeeded: T[];
+    /**
+     * Results from the chunks that were successfully processed before the error occurred.
+     */
+    readonly succeededResults: U[];
+    /**
+     * Input items from the chunk that failed and caused the error.
+     */
+    readonly failed: T[];
+    /**
+     * Input items from chunks that were never processed due to the error.
+     * This includes both chunks that were never started and chunks that were
+     * in-progress when the error occurred.
+     */
+    readonly unprocessed: T[];
+    constructor(reason: Error, succeeded: T[], succeededResults: U[], failed: T[], unprocessed: T[]);
+}
+/**
+ * Splits an array into chunks and processes each chunk in parallel using a callback function.
+ *
+ * This function is useful for batch processing large datasets where you want to:
+ * - Limit the number of items processed at once (e.g., API limits)
+ * - Process multiple chunks simultaneously for better performance
+ * - Control the degree of parallelism to avoid overwhelming resources
+ *
+ * The function maintains a saturated queue up to `numWorkers` concurrent operations.
+ * When one chunk completes, the next chunk starts immediately, ensuring optimal throughput.
+ *
+ * All chunks are processed with controlled parallelism, and the results are flattened into
+ * a single array. If any chunk fails, the entire operation fails.
+ * The order of the result is maintained regardless of the completion order of the
+ * chunks, but not that there is no requirement that the callback must return one
+ * result per input element (i.e. the number of result elements might differ from the
+ * number of input elements).
+ *
+ * @template T - The type of elements in the input array.
+ * @template U - The type of elements in the output array.
+ * @param workItems - The array of items to process.
+ * @param chunkSize - The maximum size of each chunk. Must be a positive integer.
+ * @param performWorkCallback - An async function that processes a chunk and returns results.
+ * @param options - Optional configuration for parallelism control.
+ * @returns A promise that resolves to a flattened array of all results.
+ * @throws {Error} If `chunkSize` is not a positive integer or `numWorkers` is not a positive integer.
+ * @throws {PartialExecutionError} If `performWorkCallback` throws an error for any chunk, providing details about succeeded, failed, and unprocessed items.
+ *
+ * @example
+ * ```ts
+ * // Batch retrieve assets from CDF with controlled parallelism
+ * const assetIds = [1, 2, 3, ..., 10000];
+ * const assets = await chunkAndProcessInParallel(
+ *   assetIds,
+ *   1000, // Retrieve 1000 assets per request
+ *   async (chunk) => {
+ *     const response = await client.assets.retrieve(
+ *       chunk.map(id => ({ id }))
+ *     );
+ *     return response;
+ *   },
+ *   { numWorkers: 5 } // Process at most 5 chunks concurrently
+ * );
+ * // Result: All assets from all chunks combined
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Handle partial execution errors
+ * try {
+ *   const results = await chunkAndProcessInParallel(
+ *     largeDataset,
+ *     100,
+ *     async (chunk) => processChunk(chunk),
+ *     { numWorkers: 3 }
+ *   );
+ * } catch (error) {
+ *   if (error instanceof PartialExecutionError) {
+ *     console.log(`Successfully processed ${error.succeeded.length} items`);
+ *     console.log(`Failed to process ${error.failed.length} items`);
+ *     console.log(`Did not attempt ${error.unprocessed.length} items`);
+ *     console.error('Failure reason:', error.reason);
+ *     // Optionally retry only the failed and unprocessed items
+ *   }
+ *   throw error;
+ * }
+ * ```
+ */
+export declare function chunkAndProcessInParallel<T, U>(workItems: T[], chunkSize: number, performWorkCallback: (workItemsChunk: T[]) => Promise<U[]>, options?: ChunkAndProcessOptions): Promise<U[]>;

package/dist/chunk-and-process-in-parallel.js

@@ -0,0 +1,30 @@
+import { chunkArray as e } from "./chunk-array.js";
+//#region libs/shared/underscore/src/chunk-and-process-in-parallel.ts
+var t = class extends Error {
+	constructor(e, t, n, r, i) {
+		super(`${e.message} (succeeded: ${t.length}, failed: ${r.length}, unprocessed: ${i.length})`), this.name = "PartialExecutionError", this.reason = e, this.succeeded = t, this.succeededResults = n, this.failed = r, this.unprocessed = i, this.message = `Processing failed for ${r.length} items: ${e.message}`;
+	}
+};
+async function n(n, r, i, a) {
+	let o = a?.numWorkers ?? 10;
+	if (o <= 0 || !Number.isInteger(o)) throw Error("numWorkers must be a positive integer");
+	let s = Array.from(e(n, r));
+	if (s.length === 0) return [];
+	let c = Array(s.length), l = 0, u = !1, d = /* @__PURE__ */ new Set(), f = async () => {
+		for (; !u && l < s.length;) {
+			let e = l++;
+			try {
+				let t = await i(s[e]);
+				c[e] = t, d.add(e);
+			} catch (n) {
+				u = !0;
+				let r = [], i = [], a = [];
+				for (let t = 0; t < s.length; t++) d.has(t) ? (r.push(...s[t]), i.push(...c[t])) : t !== e && a.push(...s[t]);
+				throw new t(n instanceof Error ? n : Error(String(n)), r, i, s[e], a);
+			}
+		}
+	}, p = Array.from({ length: Math.min(o, s.length) }, () => f());
+	return await Promise.all(p), c.flat();
+}
+//#endregion
+export { t as PartialExecutionError, n as chunkAndProcessInParallel };

package/dist/chunk-array.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Splits an array into smaller chunks of a specified size using a generator. If the
+ * array length is not evenly divisible by `chunkSize`, the final chunk will contain
+ * the remaining elements.
+ *
+ * @template T - The type of elements in the array.
+ * @param array - The array to split into chunks.
+ * @param chunkSize - The maximum size of each chunk. Must be a positive integer.
+ * @returns A generator that yields arrays of size `chunkSize` (or smaller for the last chunk).
+ * @throws {Error} If `chunkSize` is not a positive integer.
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const chunks = Array.from(chunkArray([1, 2, 3, 4, 5], 2));
+ * // Result: [[1, 2], [3, 4], [5]]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Process chunks lazily using for...of
+ * for (const chunk of chunkArray([1, 2, 3, 4, 5, 6], 3)) {
+ *   console.log(chunk); // Logs: [1, 2, 3], then [4, 5, 6]
+ * }
+ * ```
+ */
+export declare function chunkArray<T>(array: T[], chunkSize: number): Generator<T[], void, unknown>;

package/dist/chunk-array.js

@@ -0,0 +1,7 @@
+//#region libs/shared/underscore/src/chunk-array.ts
+function* e(e, t) {
+	if (t <= 0 || !Number.isInteger(t)) throw Error(`chunkSize must be an integer greater than 0, but got ${t}`);
+	for (let n = 0; n < e.length; n += t) yield e.slice(n, n + t);
+}
+//#endregion
+export { e as chunkArray };

package/dist/class.d.ts

@@ -0,0 +1,12 @@
+export type Class<T> = Function & {
+    prototype: T;
+};
+/**
+ * Returns true if the value is an instance of the given class type.
+ *
+ * @template T - The type of the class instance.
+ * @param value - The value to check
+ * @param classType - The class type to expect.
+ * @returns True if the value is an instance of the given class type.
+ */
+export declare function isInstanceOf<T>(value: unknown, classType: Class<T>): value is T;

package/dist/class.js

@@ -0,0 +1,6 @@
+//#region libs/shared/underscore/src/class.ts
+function e(e, t) {
+	return e instanceof t;
+}
+//#endregion
+export { e as isInstanceOf };

package/dist/exhaustive-guard.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This will cause a type error if the switch statement is not exhaustive.
+ *
+ * @example
+ * ```ts
+ * type Value = 'a' | 'b';
+ * const value: Value = 'a';
+ * switch (value) {
+ *  case 'a':
+ *   return 'A';
+ *  default:
+ *    // This will cause a type error as we are missing the case for 'b'
+ *    return exhaustiveGuard(value);
+ * }
+ * ```
+ */
+export declare function exhaustiveGuard(_value: never): never;

package/dist/exhaustive-guard.js

@@ -0,0 +1,6 @@
+//#region libs/shared/underscore/src/exhaustive-guard.ts
+function e(e) {
+	throw Error(`ERROR! Reached forbidden guard function with unexpected value: ${JSON.stringify(e)}`);
+}
+//#endregion
+export { e as exhaustiveGuard };

package/dist/exponential-backoff-with-jitter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Calculates the delay in milliseconds for the next retry attempt. Uses "exponential backoff with
+ * full jitter" algorithm.
+ *
+ * `floor(random() * min(2 ** attempt * baseDelayInMs, maxDelayInMs))`
+ *
+ * @see https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+ *
+ * @param attempt - The current attempt (1-based).
+ * @param baseDelayInMs - The base delay in milliseconds. Default is 250ms.
+ * @param maxDelayInMs - The maximum delay in milliseconds. Default is 15,000ms (15 seconds).
+ * @param randomCallback - A callback function that returns a random number between 0 (inclusive) and 1 (exclusive). Default is Math.random. Provided for testing/mocking purposes.
+ * @returns The delay in milliseconds for the next retry attempt.
+ */
+export declare function exponentialBackoffWithJitter(attempt: number, baseDelayInMs?: number, maxDelayInMs?: number, randomCallback?: typeof Math.random): number;

package/dist/exponential-backoff-with-jitter.js

@@ -0,0 +1,8 @@
+//#region libs/shared/underscore/src/exponential-backoff-with-jitter.ts
+function e(e, t = 250, n = 15e3, r = Math.random) {
+	if (e < 1) throw Error("`attempt` must be 1 or greater");
+	let i = 2 ** e * t, a = Math.min(i, n);
+	return Math.floor(r() * a);
+}
+//#endregion
+export { e as exponentialBackoffWithJitter };

package/dist/generate-unique-name.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generates a unique name based on a prefix and existing names.
+ * If no existing names match the prefix, returns the prefix as-is.
+ * Otherwise, appends the next available number to the prefix.
+ *
+ * @param existingNames - Array of existing names to check against
+ * @param prefix - The prefix to use for the unique name
+ * @returns A unique name that doesn't conflict with existing names
+ *
+ * @example
+ * ```typescript
+ * generateUniqueName(['Untitled evaluation', 'Untitled evaluation 1'], 'Untitled evaluation')
+ * // Returns: 'Untitled evaluation 2'
+ *
+ * generateUniqueName(['Other name'], 'Untitled evaluation')
+ * // Returns: 'Untitled evaluation'
+ * ```
+ */
+export declare function generateUniqueName(existingNames: string[], prefix: string): string;

package/dist/generate-unique-name.js

@@ -0,0 +1,11 @@
+//#region libs/shared/underscore/src/generate-unique-name.ts
+function e(e, t) {
+	let n = e.filter((e) => e.startsWith(t));
+	return n.length === 0 ? t : `${t} ${n.reduce((e, n) => {
+		if (n === t) return Math.max(e, 0);
+		let r = t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), i = n.match(RegExp(`^${r} (\\d+)(?:.*)?$`));
+		return i || (i = n.match(RegExp(`^${r}[^\\w]*(\\d+)(?:.*)?$`)), i) ? Math.max(e, parseInt(i[1], 10)) : Math.max(e, 0);
+	}, 0) + 1}`;
+}
+//#endregion
+export { e as generateUniqueName };

package/dist/get-numbers-between.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Generates a sequence of numbers between the specified range.
+ *
+ * @param minInclusive - The starting number of the sequence (inclusive).
+ * @param maxExclusive - The ending number of the sequence (exclusive).
+ * @param step - The step value to increment by (default is 1).
+ * @returns A generator that yields numbers between the specified range.
+ *
+ * @example
+ * ```ts
+ * const numbers = getNumbersBetween(1, 5);
+ * for (const num of numbers) {
+ *   console.log(num); // 1, 2, 3, 4
+ * }
+ * ```
+ */
+export declare function getNumbersBetween(minInclusive: number, maxExclusive: number, step?: number): Generator<number>;

package/dist/get-numbers-between.js

@@ -0,0 +1,6 @@
+//#region libs/shared/underscore/src/get-numbers-between.ts
+function* e(e, t, n = 1) {
+	for (let r = e; r < t; r += n) yield r;
+}
+//#endregion
+export { e as getNumbersBetween };

package/dist/humanize-value.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Turns nested objects and arrays into a flat, human-readable string for UI display.
+ * Null, undefined, NaN, and empty collections render as `'-'`.
+ */
+export declare function humanizeValue(value: unknown): string;

package/dist/humanize-value.js

@@ -0,0 +1,16 @@
+import { isArray as e, isNaN as t, isObject as n } from "lodash-es";
+//#region libs/shared/underscore/src/humanize-value.ts
+function r(i) {
+	if (i == null || t(i) || e(i) && i.length === 0 || n(i) && Object.keys(i).length === 0) return "-";
+	let a = "", o = (t) => {
+		e(t) ? t.forEach((e) => {
+			o(e);
+		}) : n(t) ? Object.entries(t).forEach(([e, t]) => {
+			let n = r(t);
+			a += `${e}: ${n} `;
+		}) : a += `${String(t)} `;
+	};
+	return o(i), a.trim();
+}
+//#endregion
+export { r as humanizeValue };

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { insertAt, remove, removeAt, swap, shuffle } from './arrays';
+export { assert } from './assert';
+export type { Brand } from './brand';
+export { chunkAndProcessInParallel } from './chunk-and-process-in-parallel';
+export { chunkArray } from './chunk-array';
+export { isInstanceOf, type Class } from './class';
+export { exhaustiveGuard } from './exhaustive-guard';
+export { exponentialBackoffWithJitter } from './exponential-backoff-with-jitter';
+export { generateUniqueName } from './generate-unique-name';
+export { getNumbersBetween } from './get-numbers-between';
+export { humanizeValue } from './humanize-value';
+export { isFunction } from './is-function';
+export { isPrimitive } from './is-primitive';
+export { isValidUrl } from './is-valid-url';
+export { every } from './iterators';
+export { isEven, isOdd } from './math';
+export { randomString, randomInteger, randomFloat, randomElement, } from './random';
+export { repeat } from './repeat';
+export { retryAsync } from './retry-async';
+export { sleep } from './sleep';
+export { capitalizeFirstLetter, kebabToPascalCase, toKebabCase, } from './string';
+export type { KeySerializer } from './structMap';
+export { stableStringify, StructMap } from './structMap';

package/dist/index.js

@@ -0,0 +1,23 @@
+import { repeat as e } from "./repeat.js";
+import { randomElement as t, randomFloat as n, randomInteger as r, randomString as i } from "./random.js";
+import { insertAt as a, remove as o, removeAt as s, shuffle as c, swap as l } from "./arrays.js";
+import { assert as u } from "./assert.js";
+import { chunkArray as d } from "./chunk-array.js";
+import { chunkAndProcessInParallel as f } from "./chunk-and-process-in-parallel.js";
+import { isInstanceOf as p } from "./class.js";
+import { exhaustiveGuard as m } from "./exhaustive-guard.js";
+import { exponentialBackoffWithJitter as h } from "./exponential-backoff-with-jitter.js";
+import { generateUniqueName as g } from "./generate-unique-name.js";
+import { getNumbersBetween as _ } from "./get-numbers-between.js";
+import { humanizeValue as v } from "./humanize-value.js";
+import { isFunction as y } from "./is-function.js";
+import { isPrimitive as b } from "./is-primitive.js";
+import { isValidUrl as x } from "./is-valid-url.js";
+import { every as S } from "./iterators.js";
+import { isEven as C, isOdd as w } from "./math.js";
+import { sleep as T } from "./sleep.js";
+import { retryAsync as E } from "./retry-async.js";
+import { capitalizeFirstLetter as D, kebabToPascalCase as O, toKebabCase as k } from "./string.js";
+import { stableStringify as A } from "./structMap/stableStringify.js";
+import { StructMap as j } from "./structMap/structMap.js";
+export { j as StructMap, u as assert, D as capitalizeFirstLetter, f as chunkAndProcessInParallel, d as chunkArray, S as every, m as exhaustiveGuard, h as exponentialBackoffWithJitter, g as generateUniqueName, _ as getNumbersBetween, v as humanizeValue, a as insertAt, C as isEven, y as isFunction, p as isInstanceOf, w as isOdd, b as isPrimitive, x as isValidUrl, O as kebabToPascalCase, t as randomElement, n as randomFloat, r as randomInteger, i as randomString, o as remove, s as removeAt, e as repeat, E as retryAsync, c as shuffle, T as sleep, A as stableStringify, l as swap, k as toKebabCase };

package/dist/is-function.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if the given value is a function.
+ *
+ * @param maybeFunction - The value to check.
+ * @returns True if the value is a function, otherwise false.
+ */
+export declare function isFunction(maybeFunction: unknown): maybeFunction is Function;

package/dist/is-function.js

@@ -0,0 +1,6 @@
+//#region libs/shared/underscore/src/is-function.ts
+function e(e) {
+	return typeof e == "function";
+}
+//#endregion
+export { e as isFunction };

package/dist/is-primitive.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the given value is a primitive.
+ * Primitives include: string, number, boolean, null, undefined, symbol, and bigint.
+ * {@link https://developer.mozilla.org/en-US/docs/Glossary/Primitive}
+ *
+ * @param value - The value to check.
+ * @returns Returns true if the value is a primitive, false otherwise.
+ */
+export declare function isPrimitive(value: unknown): boolean;

package/dist/is-primitive.js

@@ -0,0 +1,7 @@
+//#region libs/shared/underscore/src/is-primitive.ts
+function e(e) {
+	let t = typeof e;
+	return e === null || t === "string" || t === "number" || t === "boolean" || t === "undefined" || t === "symbol" || t === "bigint";
+}
+//#endregion
+export { e as isPrimitive };

package/dist/is-valid-url.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Inspired by: https://github.com/segmentio/is-url
+ */
+/**
+ * Checks if a value is a valid URL.
+ *
+ * A valid URL must:
+ * - Be a string.
+ * - Start with "http://" or "https://".
+ * - Contain a valid domain name.
+ * - Not contain spaces in the host part.
+ *
+ * @param {unknown} value - The value to be checked.
+ * @returns {value is string} - Returns `true` if the value is a valid URL, otherwise `false`.
+ */
+export declare function isValidUrl(value: unknown): value is string;

package/dist/is-valid-url.js

@@ -0,0 +1,17 @@
+//#region libs/shared/underscore/src/is-valid-url.ts
+var e = /^(https?):\/\/(\S+)$/, t = /^[^\s\\.]+\.\S{2,}$/;
+function n(n) {
+	if (typeof n != "string") return !1;
+	let r = n.match(e);
+	if (!r) return !1;
+	let i = r[2];
+	if (!i || !t.test(i)) return !1;
+	try {
+		let e = new URL(n);
+		return e.protocol === "http:" || e.protocol === "https:";
+	} catch {
+		return !1;
+	}
+}
+//#endregion
+export { n as isValidUrl };

package/dist/iterators.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tests whether all elements in the iterable pass the test implemented by the provided predicate function.
+ *
+ * @template T - The type of elements in the iterable.
+ * @param {Iterable<T>} iterable - The iterable to be tested.
+ * @param {(value: T) => boolean} predicate - A function that tests each element of the iterable.
+ * @returns {boolean} - Returns `true` if all elements pass the test, otherwise `false`.
+ */
+export declare function every<T>(iterable: Iterable<T>, predicate: (value: T) => boolean): boolean;

package/dist/iterators.js

@@ -0,0 +1,7 @@
+//#region libs/shared/underscore/src/iterators.ts
+function e(e, t) {
+	for (let n of e) if (!t(n)) return !1;
+	return !0;
+}
+//#endregion
+export { e as every };