@manta-eu/lib 0.1.9 → 0.2.0

package/src/color.ts

@@ -0,0 +1,92 @@
+import type { DateArg } from "date-fns";
+import { differenceInHours } from "date-fns";
+
+export type RGBColor = {
+  r: number;
+  g: number;
+  b: number;
+};
+
+export type HexColor = `#${string}`;
+
+export const hexToRgb = (hex: HexColor): RGBColor => {
+  let sanitizedHex = hex.replace("#", "");
+
+  if (sanitizedHex.length === 3) {
+    sanitizedHex = sanitizedHex
+      .split("")
+      .map((h) => `${h}${h}`)
+      .join("");
+  }
+
+  const bigint = parseInt(sanitizedHex, 16);
+
+  if (isNaN(bigint)) throw new Error(`Invalid hex value: ${hex}`);
+
+  return {
+    r: (bigint >> 16) & 255,
+    g: (bigint >> 8) & 255,
+    b: bigint & 255,
+  };
+};
+
+export function rgbToHex({ r, g, b }: RGBColor): HexColor {
+  const componentToHex = (c: number) => {
+    const hex = c.toString(16);
+    return hex.length === 1 ? `0${hex}` : hex;
+  };
+
+  return `#${componentToHex(r)}${componentToHex(g)}${componentToHex(b)}`;
+}
+
+export function capBrightness(hexColor: HexColor, maxBrightness: number = 150): string {
+  let { r, g, b } = hexToRgb(hexColor);
+
+  r = Math.min(r, maxBrightness);
+  g = Math.min(g, maxBrightness);
+  b = Math.min(b, maxBrightness);
+
+  return rgbToHex({ r, g, b });
+}
+
+export const generateHexColorBasedOnName = (name: string) => {
+  const hash = name.split("").reduce((acc, char) => acc + char.charCodeAt(0), 0);
+
+  const color = `hsl(${hash % 360}, 50%, 50%)`;
+  const contrast = hash % 360 > 180 ? "black" : "white";
+
+  return { color, contrast };
+};
+
+export const getAverageColor = (ctx: CanvasRenderingContext2D, width: number, height: number): RGBColor => {
+  const imageData = ctx.getImageData(0, 0, width, height);
+  const data = imageData.data;
+  const length = data.length;
+
+  let r = 0,
+    g = 0,
+    b = 0,
+    count = 0;
+
+  for (let i = 0; i < length; i += 4) {
+    r += data[i]!;
+    g += data[i + 1]!;
+    b += data[i + 2]!;
+    count++;
+  }
+
+  return {
+    r: Math.floor(r / count),
+    g: Math.floor(g / count),
+    b: Math.floor(b / count),
+  };
+};
+
+export function getAgeColor(date: DateArg<Date>): string {
+  const diffInHours = differenceInHours(Date.now(), date);
+  const clampedHours = Math.min(Math.max(diffInHours, 0), 36);
+
+  const hue = Math.round(120 - clampedHours * 3.3333);
+
+  return `hsl(${hue}, 80%, 40%)`;
+}

package/src/connection-string.ts

@@ -0,0 +1,95 @@
+import { isPresent } from "./present";
+
+export type ConnectionString = {
+  scheme: string;
+  host?: string;
+  port?: string;
+  username?: string;
+  password?: string;
+  path: string[];
+  params: Record<string, string>;
+};
+
+export type ParseOptions = {
+  // A URL can hold a raw ";" in its user name or password, so only a JDBC format that uses ";KEY=VALUE" sets this.
+  semicolonProperties?: boolean;
+};
+
+export function parseConnectionString(input: string, options: ParseOptions = {}): ConnectionString | undefined {
+  const { semicolonProperties = false } = options;
+  const schemeAndRest = splitScheme(stripJdbcPrefix(input.trim()));
+  if (!schemeAndRest) return undefined;
+
+  const { scheme, rest } = schemeAndRest;
+  const [head, properties] = semicolonProperties ? splitHead(rest) : [rest, ""];
+  if (head.includes("\\")) return undefined;
+
+  try {
+    const { path, query, ...authority } = headParts(scheme, head, semicolonProperties);
+    return {
+      scheme,
+      ...withoutBlankValues(authority),
+      path,
+      params: Object.fromEntries([...query, ...propertyEntries(properties)]),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+export function unescapeBracedValue(value: string): string {
+  const braced = /^\{(.*)\}$/s.exec(value);
+  return braced?.[1] === undefined ? value : braced[1].replaceAll("}}", "}");
+}
+
+function stripJdbcPrefix(input: string): string {
+  return input.replace(/^jdbc:/i, "");
+}
+
+const schemePattern = /^([a-z][a-z0-9+.-]*):\/\//i;
+
+function splitScheme(text: string): { scheme: string; rest: string } | undefined {
+  const match = schemePattern.exec(text);
+  if (!match?.[1]) return undefined;
+  return { scheme: match[1].toLowerCase(), rest: text.slice(match[0].length) };
+}
+
+function splitHead(text: string): [string, string] {
+  const [head = "", ...properties] = text.split(";");
+  return [head, properties.join(";")];
+}
+
+// The BigQuery JDBC head is an endpoint URL, so a head with its own scheme carries no host.
+function headParts(scheme: string, head: string, semicolonProperties: boolean) {
+  if (!isPresent(head) || (semicolonProperties && head.includes("://"))) return { path: [], query: [] };
+  return urlParts(scheme, head);
+}
+
+function urlParts(scheme: string, head: string) {
+  const url = new URL(`${scheme}://${head}`);
+
+  return {
+    host: url.hostname.replace(/^\[(.*)\]$/, "$1"),
+    port: url.port,
+    username: decodeURIComponent(url.username),
+    password: decodeURIComponent(url.password),
+    path: url.pathname.split("/").filter(Boolean).map(decodeURIComponent),
+    query: [...url.searchParams],
+  };
+}
+
+function withoutBlankValues(entries: Record<string, string>): Record<string, string> {
+  return Object.fromEntries(Object.entries(entries).filter(([, value]) => isPresent(value)));
+}
+
+const propertyName = "([^;=]+)";
+// The SQL Server JDBC driver escapes a value in braces, and "}}" in the braces stands for one "}".
+const bracedValue = String.raw`\{(?:[^}]|\}\})*\}`;
+const plainValue = "[^;]*";
+const propertyPattern = new RegExp(String.raw`${propertyName}=\s*(${bracedValue}|${plainValue})`, "g");
+
+function propertyEntries(text: string): [string, string][] {
+  return [...text.matchAll(propertyPattern)]
+    .map(([, name = "", value = ""]): [string, string] => [name.trim(), value.trim()])
+    .filter(([name]) => isPresent(name));
+}

package/src/countries.ts

@@ -0,0 +1,18 @@
+const regionDisplayNames = new Intl.DisplayNames(["en"], { type: "region" });
+const languageDisplayNames = new Intl.DisplayNames(["en"], { type: "language" });
+
+export function getCountryName(countryCode: string) {
+  try {
+    return regionDisplayNames.of(countryCode) ?? countryCode;
+  } catch {
+    return countryCode;
+  }
+}
+
+export function getLanguageName(languageCode: string) {
+  try {
+    return languageDisplayNames.of(languageCode.toLowerCase()) ?? languageCode;
+  } catch {
+    return languageCode;
+  }
+}

package/src/custom-app.ts

@@ -0,0 +1,180 @@
+import { isPresent } from "./present";
+
+export const customAppClientIdPrefix = "ext-";
+// As the plugin's own pattern: anything else names no app, and each name would get its own rate limiter.
+export const customAppClientIdPattern = /^ext-[a-z0-9-]+$/;
+export const maxCustomAppClientIdLength = 64;
+
+export function customAppClientIdProblem(clientId: unknown): string | undefined {
+  if (
+    typeof clientId !== "string" ||
+    clientId.length > maxCustomAppClientIdLength ||
+    !customAppClientIdPattern.test(clientId)
+  ) {
+    return `${JSON.stringify(clientId)} is not a custom app's client ID, ext-...`;
+  }
+  return undefined;
+}
+
+const loopbackHosts = new Set(["localhost", "127.0.0.1", "[::1]"]);
+const maxRedirectUrlLength = 2048;
+
+// Keycloak compares a redirect URL with what the app sends as an exact string, so it is stored as typed.
+export function redirectUrlProblem(raw: string): string | undefined {
+  if (raw.length > maxRedirectUrlLength) return `Keep it under ${maxRedirectUrlLength} characters`;
+  if (raw.includes("*")) return "Wildcards are not allowed";
+  if (/[\s,]/.test(raw)) return "Leave out commas and spaces, one URL per field";
+
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    return "Enter a full URL, like https://app.example.com/callback";
+  }
+
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopbackHosts.has(url.hostname))) {
+    return "Use https, or http for localhost";
+  }
+  if (isPresent(url.username) || isPresent(url.password)) return "Leave out the username and password";
+  if (isPresent(url.hash)) return "Leave out the #fragment";
+  return undefined;
+}
+
+export const customAppUsersIdpAlias = "manta-custom-app-users";
+export const customAppUsersPath = "/agents/custom-app-users";
+export const customAppUserTokenPath = `${customAppUsersPath}/token`;
+export const customAppUserIdPattern = /^[A-Za-z0-9_.@|-]{1,128}$/;
+export const customAppUserFieldKeyPattern = /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/;
+export const maxCustomAppUserFields = 50;
+export const maxCustomAppUserFieldLength = 1024;
+// The fields marked for the agent ride in every access token, so they are held well under a request header's size.
+export const maxCustomAppUserAgentFieldsLength = 4096;
+export const maxCustomAppUserNameLength = 200;
+export const maxCustomAppUserEmailLength = 320;
+export const maxCustomAppUserTeams = 50;
+export const maxCustomAppUserDatastores = 50;
+const maxTeamPathLength = 255;
+
+export type CustomAppUserFieldValue = string | number | boolean;
+export type CustomAppUserField = { value: CustomAppUserFieldValue; agent?: boolean };
+
+export type CustomAppUserProfile = {
+  name?: string;
+  email?: string;
+  fields?: Record<string, CustomAppUserField>;
+};
+
+export type CustomAppUserTokenRequest = CustomAppUserProfile & {
+  client_id: string;
+  client_secret: string;
+  user_id?: string;
+  anonymous_id?: string;
+  datastores?: string[];
+  teams?: string[];
+};
+
+export function customAppUserTeamsProblem(teams: unknown): string | undefined {
+  if (teams === undefined) return undefined;
+  if (!Array.isArray(teams) || teams.length > maxCustomAppUserTeams)
+    return `teams lists at most ${maxCustomAppUserTeams} teams`;
+  const bad = teams.find(
+    (team) => typeof team !== "string" || !team.startsWith("/") || team.length < 2 || team.length > maxTeamPathLength,
+  );
+  return bad === undefined ? undefined : `A team is its path, like /Sales/EU; ${JSON.stringify(bad)} is not one`;
+}
+
+export function customAppUserDatastoresProblem(datastores: unknown): string | undefined {
+  if (datastores === undefined) return undefined;
+  if (!Array.isArray(datastores) || !isPresent(datastores) || datastores.length > maxCustomAppUserDatastores) {
+    return `datastores lists 1 to ${maxCustomAppUserDatastores} datastores, or is left out`;
+  }
+  const bad = datastores.find((datastore) => typeof datastore !== "string" || !isPresent(datastore));
+  return bad === undefined ? undefined : `A datastore is its id; ${JSON.stringify(bad)} is not one`;
+}
+
+export type CustomAppUserTokenResponse = { access_token: string; token_type: "Bearer"; expires_in: number };
+
+export function customAppUserSubject(clientId: string, userId: string): string {
+  return `app:${clientId}:${userId}`;
+}
+
+export function customAppUserIdOfSubject(clientId: string, subject: string | undefined): string | undefined {
+  const prefix = customAppUserSubject(clientId, "");
+  return subject?.startsWith(prefix) === true && subject.length > prefix.length
+    ? subject.slice(prefix.length)
+    : undefined;
+}
+
+// Every anonymous visitor of one app shares this account; the visitor id rides in the token instead.
+export function anonymousSubject(clientId: string): string {
+  return `anon:${clientId}`;
+}
+
+// Only accounts the Worker made carry app.<client id>.<hash>; an upgrade renames the account to its email.
+const generatedCustomAppUsername = /^app\.(ext-[a-z0-9-]+)\.([0-9a-f]{32}|anonymous)$/;
+
+export function customAppClientIdOfUsername(username: string | undefined): string | undefined {
+  return generatedCustomAppUsername.exec(username ?? "")?.[1];
+}
+
+export function customAppUsernamePrefix(clientId: string): string {
+  return `app.${clientId}.`;
+}
+
+export function anonymousPrincipalId(clientId: string, anonymousId: string): string {
+  return `anon:${clientId}:${anonymousId}`;
+}
+
+export function customAppUserIdProblem(userId: unknown): string | undefined {
+  if (typeof userId !== "string" || !customAppUserIdPattern.test(userId)) {
+    return "A custom app user id is 1 to 128 letters, digits or - _ . @ |";
+  }
+  return undefined;
+}
+
+function fieldProblem(key: string, field: unknown): string | undefined {
+  if (!customAppUserFieldKeyPattern.test(key))
+    return `Field name "${key}" must start with a letter and use letters, digits, - _ .`;
+  if (typeof field !== "object" || field === null || !("value" in field)) return `Field "${key}" needs a value`;
+  const { value, agent } = field as { value: unknown; agent?: unknown };
+  if (!["string", "number", "boolean"].includes(typeof value))
+    return `Field "${key}" must be a string, number or boolean`;
+  if (typeof value === "string" && value.length > maxCustomAppUserFieldLength) {
+    return `Field "${key}" is longer than ${maxCustomAppUserFieldLength} characters`;
+  }
+  if (agent !== undefined && typeof agent !== "boolean") return `Field "${key}" marks agent with true or false`;
+  return undefined;
+}
+
+export function customAppUserProfileProblem(profile: CustomAppUserProfile): string | undefined {
+  const { name, email, fields } = profile;
+  if (name !== undefined && (typeof name !== "string" || name.length > maxCustomAppUserNameLength)) {
+    return `A name is text of at most ${maxCustomAppUserNameLength} characters`;
+  }
+  if (
+    email !== undefined &&
+    (typeof email !== "string" || email.length > maxCustomAppUserEmailLength || !email.includes("@"))
+  ) {
+    return "An email needs an @ and at most 320 characters";
+  }
+  if (fields === undefined) return undefined;
+  if (typeof fields !== "object" || fields === null || Array.isArray(fields))
+    return "Fields are an object of named fields";
+  const entries = Object.entries(fields);
+  if (entries.length > maxCustomAppUserFields) return `At most ${maxCustomAppUserFields} fields`;
+  for (const [key, field] of entries) {
+    const problem = fieldProblem(key, field);
+    if (problem !== undefined) return problem;
+  }
+  const agentFieldsLength = entries.reduce(
+    (length, [key, field]) =>
+      (field as { agent?: boolean }).agent === true
+        ? length + key.length + String((field as { value: unknown }).value).length
+        : length,
+    0,
+  );
+  if (agentFieldsLength > maxCustomAppUserAgentFieldsLength) {
+    return `The fields marked for the agent come to at most ${maxCustomAppUserAgentFieldsLength} characters, names included`;
+  }
+  return undefined;
+}

package/src/date.ts

@@ -0,0 +1,51 @@
+import type { DateArg, FormatOptions } from "date-fns";
+import { format, formatISO, set } from "date-fns";
+import { take } from "ramda";
+import { parseInteger } from "./number";
+
+export function setTime<DateType extends Date, ResultDate extends Date = DateType>(
+  date: DateArg<DateType>,
+  time: string,
+): ResultDate;
+
+export function setTime<DateType extends Date, ResultDate extends Date = DateType>(
+  date: DateArg<DateType>,
+  hours: number,
+  minutes: number,
+): ResultDate;
+
+export function setTime<DateType extends Date, ResultDate extends Date = DateType>(
+  date: DateArg<DateType>,
+  timeOrHour: string | number,
+  optMinutes?: number,
+): ResultDate {
+  let hours: number | undefined;
+  let minutes: number | undefined;
+
+  if (typeof timeOrHour === "string") {
+    [hours, minutes] = take(2, timeOrHour.split(":", 3)).map(parseInteger);
+  } else {
+    hours = timeOrHour;
+    minutes = optMinutes;
+  }
+
+  return set(date, { hours, minutes, seconds: 0, milliseconds: 0 });
+}
+
+export function formatDate(date: DateArg<Date> & {}): string {
+  return format(date, "yyyy-MM-dd");
+}
+
+export function formatISODate(date: DateArg<Date>): string {
+  return formatISO(date, { representation: "date" });
+}
+
+export type FormatTimeOptions = Intl.DateTimeFormatOptions;
+
+export function formatTime(date: Date, options: FormatTimeOptions = {}): string {
+  return date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", ...options });
+}
+
+export function formatDateTime(date: DateArg<Date>, formatStr = "yyyy-MM-dd HH:mm", options?: FormatOptions): string {
+  return format(date, formatStr, options);
+}

package/src/enum.ts

@@ -0,0 +1,18 @@
+import { identity } from "ramda";
+
+export type Option<T extends string> = {
+  id: T;
+  label: string;
+};
+
+export function enumToOptions<T extends string>(
+  enums: T[],
+  labelFunction: (value: T) => string = identity,
+): Option<T>[] {
+  return enums
+    .map((value) => ({
+      id: value,
+      label: labelFunction(value),
+    }))
+    .sort((a, b) => a.label.localeCompare(b.label));
+}

package/src/file.ts

@@ -0,0 +1,19 @@
+export function getExtension(filename: string) {
+  const lastDotIndex = filename.lastIndexOf(".");
+
+  if (lastDotIndex <= 0 || lastDotIndex === filename.length - 1) {
+    return undefined;
+  }
+
+  return filename.slice(lastDotIndex + 1).toLowerCase();
+}
+
+export function getBasename(filename: string) {
+  const lastDotIndex = filename.lastIndexOf(".");
+
+  return lastDotIndex === -1 ? filename : filename.slice(0, lastDotIndex);
+}
+
+export function fileIdentityKey(file: File) {
+  return `${file.name}-${file.size}-${file.lastModified}`;
+}

package/src/humanize.ts

@@ -0,0 +1,94 @@
+import type { DateArg, Duration, DurationUnit } from "date-fns";
+import { formatDuration, intervalToDuration } from "date-fns";
+import { filesize } from "filesize";
+import pluralize from "pluralize";
+import { isPresent } from "./present";
+
+export function humanBytes(input: number): string {
+  return filesize(input, {
+    base: 2,
+    separator: ".",
+    standard: "jedec",
+  }) as string;
+}
+
+export function humanCount(count: number, word: string): string {
+  return pluralize(word, count, true);
+}
+
+export function humanNumber(num: bigint | number): string {
+  const n = Number(num);
+  if (n >= 1000000) {
+    return `${(n / 1000000).toFixed(1)}M`;
+  }
+  if (n >= 1000) {
+    return `${(n / 1000).toFixed(1)}K`;
+  }
+  return n.toString();
+}
+
+export function humanizeEnum(value: string | undefined): string | undefined {
+  if (!isPresent(value)) return undefined;
+
+  return value
+    .toLowerCase()
+    .split(/[_-]/)
+    .filter(isPresent)
+    .map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`)
+    .join(" ");
+}
+
+export function humanDimensions({ width, height }: { width: number; height: number }): string {
+  return `${width}x${height}`;
+}
+
+export function humanPlural(word: string, count: number): string {
+  return pluralize(word, count, false);
+}
+
+export type HumanListOptions = Intl.ListFormatOptions & {
+  truncateAt?: number;
+};
+
+export function humanList(list: string[], options?: HumanListOptions): string {
+  const { truncateAt, ...formatOptions } = options || {};
+  const listFormat = new Intl.ListFormat("en", formatOptions);
+
+  if (!truncateAt || list.length <= truncateAt) {
+    return listFormat.format(list);
+  }
+
+  const remaining = list.length - truncateAt;
+  const truncated = [...list.slice(0, truncateAt), `+${remaining} more`];
+
+  return listFormat.format(truncated);
+}
+
+export type HumanDurationArgs = {
+  start: DateArg<Date>;
+  end: DateArg<Date>;
+  largest?: number;
+};
+
+const periods = ["years", "months", "weeks", "days", "hours", "minutes", "seconds"] as const satisfies DurationUnit[];
+
+function getDurationFormat(duration: Duration, largest: number): DurationUnit[] {
+  const formats = periods.reduce((acc, period) => {
+    return acc.length < largest && duration[period] ? [...acc, period] : acc;
+  }, [] as DurationUnit[]);
+
+  return formats.length === 0 ? ["seconds"] : formats;
+}
+
+export function humanDuration(args: HumanDurationArgs): string {
+  const { start, end, largest } = args;
+
+  const duration = intervalToDuration({
+    start,
+    end,
+  });
+
+  return formatDuration(duration, {
+    format: largest ? getDurationFormat(duration, largest) : undefined,
+  });
+}

package/src/identifier-words.ts

@@ -0,0 +1,16 @@
+// Splits a programmer identifier into words: `actionPlan_v2` becomes `action Plan v2`.
+export const identifierWordRules: ReadonlyArray<readonly [pattern: string, replacement: string]> = [
+  ["_", " "],
+  ["([a-z])([A-Z])", "$1 $2"],
+  ["([A-Z])([A-Z][a-z])", "$1 $2"],
+  ["([a-z])([0-9])", "$1 $2"],
+  ["([0-9])([A-Z][a-z])", "$1 $2"],
+  ["([0-9]+)x", " $1x"],
+  ["  *", " "],
+];
+
+export function splitIdentifierWords(raw: string): string {
+  return identifierWordRules
+    .reduce((text, [pattern, replacement]) => text.replace(new RegExp(pattern, "g"), replacement), raw)
+    .trim();
+}

package/src/number.ts

@@ -0,0 +1,10 @@
+export function parseInteger(input?: string | null): number | undefined {
+  if (input && input.trim().length > 0) {
+    const number = parseInt(input, 10);
+    if (!isNaN(number)) {
+      return number;
+    }
+  }
+
+  return;
+}

package/src/object-url.ts

@@ -0,0 +1,10 @@
+export const createObjectURL = (file: File | Blob | undefined): string => {
+  if (!file) return "";
+  return URL.createObjectURL(file);
+};
+
+export const revokeObjectURL = (url: string): void => {
+  if (url && url.startsWith("blob:")) {
+    URL.revokeObjectURL(url);
+  }
+};

package/src/present.ts

@@ -0,0 +1,30 @@
+// After https://apidock.com/rails/Object/blank%3F
+
+export function isPresent(value: string | null | undefined): value is string;
+export function isPresent<T>(value: T[] | null | undefined): value is [T, ...T[]];
+export function isPresent(value: Record<string, unknown> | null | undefined): value is Record<string, unknown>;
+export function isPresent<T>(value: T | null | undefined): value is T;
+export function isPresent<T>(value: T | null | undefined): value is NonNullable<T> {
+  if (value === null || value === undefined || value === false) {
+    return false;
+  }
+
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+
+  if (typeof value === "object") {
+    if (Object.keys(value).length > 0) return true;
+    if (value instanceof Map || value instanceof Set) return value.size > 0;
+    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return value.byteLength > 0;
+
+    const prototype = Object.getPrototypeOf(value);
+    return prototype !== Object.prototype && prototype !== null;
+  }
+
+  return true;
+}

package/src/set.ts

@@ -0,0 +1,38 @@
+// A Set that removes its oldest member to make room when it is full. Only its add method changes.
+// A copy such as `new Set(bounded)` keeps the members but not the limit.
+export function boundedSet<T>(limit: number): Set<T> {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new RangeError(`A bounded set needs a whole limit of 1 or more, but it got ${limit}.`);
+  }
+
+  const set = new Set<T>();
+  const nativeAdd = Set.prototype.add.bind(set);
+
+  set.add = (value) => {
+    if (!set.has(value) && set.size >= limit) removeOldest(set);
+    return nativeAdd(value);
+  };
+
+  return set;
+}
+
+function removeOldest<T>(set: Set<T>): void {
+  const oldest = set.values().next();
+  if (!oldest.done) set.delete(oldest.value);
+}
+
+export function addAll<T>(set: Set<T>, items: Array<T>): void;
+export function addAll<T>(set: Set<T>, other: Set<T>): void;
+export function addAll<T>(set: Set<T>, items: unknown): void {
+  if (Array.isArray(items)) {
+    items.forEach((item) => set.add(item));
+    return;
+  }
+
+  if (items instanceof Set) {
+    items.forEach((item) => set.add(item));
+    return;
+  }
+
+  throw new Error("Unsupported type");
+}

package/src/sleep.ts

@@ -0,0 +1,3 @@
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}