@tempots/std 0.9.2 → 0.9.5

package/README.md

@@ -0,0 +1,3 @@
+# @tempots/std
+
+A standard library for TypeScript.

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@tempots/std",
-  "version": "0.9.2",
+  "version": "0.9.5",
   "type": "module",
   "scripts": {
     "watch": "tsc --watch",
     "build": "tsc",
     "test": "vitest",
-    "publish": "npm publish --access public"
+    "publish": "(cp README.md package.json dist && cd dist && npm publish --access public)"
   },
   "devDependencies": {
     "@types/node": "^18.15.11",

package/dist/arrays.d.ts

@@ -1,49 +0,0 @@
-/**
- * Utility functions to manipulate `Array` values.
- */
-import { Maybe } from './maybe';
-import { type Ordering, type Compare } from './ord';
-import { type Primitive } from './types/utility';
-export declare function map<A, B>(arr: A[], f: (a: A, index: number) => B): B[];
-export declare function mapNotNull<A, B>(arr: A[], f: (a: A, index: number) => B | null | undefined): B[];
-export declare function flatMap<A, B>(arr: A[], f: (a: A) => B[]): B[];
-export declare function head<A>(arr: A[]): Maybe<A>;
-export declare function tail<A>(arr: A[]): A[];
-export declare function equals<T>(a: T[], b: T[], equality: (a: T, b: T) => boolean): boolean;
-export declare function makeEquals<T>(equality: (a: T, b: T) => boolean): (a: T[], b: T[]) => boolean;
-export declare function isEmpty<T>(arr: T[]): arr is [];
-export declare function hasValues<T>(arr: T[]): arr is [T, ...T[]];
-export declare function filter<T>(arr: T[], predicate: (v: T) => boolean): T[];
-export declare function filterNulls<T>(arr: Array<T | null | undefined>): T[];
-export declare function flatten<T>(arr: T[][]): T[];
-export declare function foldLeft<T, B>(arr: T[], f: (acc: B, curr: T) => B, b: B): B;
-export declare function all<T>(arr: T[], predicate: (v: T) => boolean): boolean;
-export declare function any<T>(arr: T[], predicate: (v: T) => boolean): boolean;
-export declare function each<T>(arr: T[], f: (v: T) => void): void;
-export declare function concat<A>(...arrs: A[][]): A[];
-export declare function makeCompare<A>(comparef: Compare<A>, shorterFirst?: boolean): (a: A[], b: A[]) => number;
-export declare function sort<A>(compare: (a: A, b: A) => Ordering, arr: A[]): A[];
-export declare function range<A>(length: number, f: (index: number) => A): A[];
-export declare function numbersRange(length: number, startAt?: number): number[];
-export declare function fill<A>(length: number, value: A): A[];
-export declare function distinctPrimitive<T extends Primitive>(values: T[]): T[];
-export declare function distinctByPredicate<T>(values: T[], predicate: (a: T) => string): T[];
-export declare function remove<A>(arr: A[], item: A, predicate?: (a: A) => boolean): boolean;
-export declare function ofIterableIterator<A>(it: IterableIterator<A>): A[];
-export interface DiffOperations<T> {
-    removals: Array<{
-        at: number;
-        qt: number;
-    }>;
-    swaps: Array<{
-        from: number;
-        to: number;
-    }>;
-    inserts: Array<{
-        at: number;
-        values: T[];
-    }>;
-}
-export declare function diffOperations<T, K>(from: T[], to: T[], getKey: (v: T) => K): DiffOperations<T>;
-export declare function applyOperations<T>(operations: DiffOperations<T>, start: T[]): T[];
-export declare function joinWithConjunction<A>(arr: A[], conjunction?: string, separator?: string): string;

package/dist/arrays.js

@@ -1,249 +0,0 @@
-/*
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    https://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-/**
- * Utility functions to manipulate `Array` values.
- */
-import { Maybe } from './maybe';
-import { keys } from './objects';
-export function map(arr, f) {
-    return Array.from({ length: arr.length }, (_, i) => f(arr[i], i));
-}
-export function mapNotNull(arr, f) {
-    const buff = [];
-    for (let i = 0; i < arr.length; i++) {
-        const v = f(arr[i], i);
-        if (v != null) {
-            buff.push(v);
-        }
-    }
-    return buff;
-}
-export function flatMap(arr, f) {
-    const buff = [];
-    for (const el of arr) {
-        buff.push(...f(el));
-    }
-    return buff;
-}
-export function head(arr) {
-    return arr.length > 0 ? arr[0] : Maybe.nothing;
-}
-export function tail(arr) {
-    return arr.slice(1);
-}
-export function equals(a, b, equality) {
-    if (a.length !== b.length)
-        return false;
-    else {
-        for (let i = 0; i < a.length; i++) {
-            if (!equality(a[i], b[i]))
-                return false;
-        }
-        return true;
-    }
-}
-export function makeEquals(equality) {
-    return function (a, b) {
-        return equals(a, b, equality);
-    };
-}
-export function isEmpty(arr) {
-    return arr.length === 0;
-}
-export function hasValues(arr) {
-    return arr.length > 0;
-}
-export function filter(arr, predicate) {
-    const buff = [];
-    for (const a of arr)
-        if (predicate(a))
-            buff.push(a);
-    return buff;
-}
-export function filterNulls(arr) {
-    return filter(arr, v => v != null);
-}
-export function flatten(arr) {
-    return [].concat(...arr);
-}
-export function foldLeft(arr, f, b) {
-    for (const a of arr) {
-        b = f(b, a);
-    }
-    return b;
-}
-export function all(arr, predicate) {
-    for (const a of arr) {
-        if (!predicate(a)) {
-            return false;
-        }
-    }
-    return true;
-}
-export function any(arr, predicate) {
-    for (const a of arr) {
-        if (predicate(a)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function each(arr, f) {
-    for (const a of arr)
-        f(a);
-}
-export function concat(...arrs) {
-    return [].concat(...arrs);
-}
-export function makeCompare(comparef, shorterFirst = true) {
-    return function (a, b) {
-        if (a.length < b.length) {
-            return -1 * (shorterFirst ? 1 : -1);
-        }
-        else if (a.length > b.length) {
-            return 1 * (shorterFirst ? 1 : -1);
-        }
-        for (let i = 0; i < a.length; i++) {
-            const ord = comparef(a[i], b[i]);
-            if (ord !== 0)
-                return ord;
-        }
-        return 0;
-    };
-}
-export function sort(compare, arr) {
-    return arr.slice().sort(compare);
-}
-export function range(length, f) {
-    return Array.from({ length }, (_, i) => f(i));
-}
-export function numbersRange(length, startAt = 0) {
-    return range(length, i => startAt + i);
-}
-export function fill(length, value) {
-    return range(length, () => value);
-}
-export function distinctPrimitive(values) {
-    return Array.from(new Set(values));
-}
-export function distinctByPredicate(values, predicate) {
-    const map = {};
-    values.forEach(v => {
-        map[predicate(v)] = v;
-    });
-    return keys(map).map(k => map[k]);
-}
-export function remove(arr, item, predicate) {
-    let index;
-    if (predicate !== undefined) {
-        index = arr.findIndex(predicate);
-    }
-    else {
-        index = arr.indexOf(item);
-    }
-    if (index < 0) {
-        return false;
-    }
-    else {
-        arr.splice(index, 1);
-        return true;
-    }
-}
-export function ofIterableIterator(it) {
-    const buff = [];
-    for (let r = it.next(); !(r.done ?? false); r = it.next()) {
-        buff.push(r.value);
-    }
-    return buff;
-}
-export function diffOperations(from, to, getKey) {
-    const ops = {
-        removals: [],
-        swaps: [],
-        inserts: []
-    };
-    const { removals, inserts, swaps } = ops;
-    const mapB = new Map();
-    to.forEach((v, i) => mapB.set(getKey(v), i));
-    const indexesOfAThatDoNotExistInB = from
-        .map((v, i) => [v, i])
-        .filter(([v]) => !mapB.has(getKey(v)))
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        .map(([_, i]) => i);
-    for (let i = indexesOfAThatDoNotExistInB.length - 1; i >= 0; i--) {
-        const p = indexesOfAThatDoNotExistInB[i];
-        const last = removals.length > 0 ? removals[removals.length - 1] : undefined;
-        if ((last != null) && last.at === p + 1) {
-            last.at--;
-            last.qt++;
-        }
-        else {
-            removals.push({ at: p, qt: 1 });
-        }
-    }
-    const mapA = new Map();
-    from.forEach((v, i) => mapA.set(getKey(v), i));
-    const indexesOfBThatDoNotExistInA = to
-        .map((v, i) => [v, i])
-        .filter(([v]) => !mapA.has(getKey(v)))
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        .map(([_, i]) => i);
-    for (const p of indexesOfBThatDoNotExistInA) {
-        const last = inserts.length > 0 ? inserts[inserts.length - 1] : undefined;
-        if ((last != null) && last.at + last.values.length === p) {
-            last.values.push(to[p]);
-        }
-        else {
-            inserts.push({ at: p, values: [to[p]] });
-        }
-    }
-    const ra = from.filter((_, i) => !indexesOfAThatDoNotExistInB.includes(i));
-    const mapRA = new Map();
-    for (let i = 0; i < ra.length; i++) {
-        mapRA.set(getKey(ra[i]), i);
-    }
-    const rb = to.filter((_, i) => !indexesOfBThatDoNotExistInA.includes(i));
-    for (let i = 0; i < rb.length; i++) {
-        const bk = getKey(rb[i]);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const ai = mapRA.get(bk);
-        if (ai == null || i === ai)
-            continue;
-        const ak = getKey(ra[i]);
-        mapRA.delete(ak);
-        swaps.push({ from: i, to: ai });
-    }
-    return ops;
-}
-export function applyOperations(operations, start) {
-    const buff = [...start];
-    for (const { at, qt } of operations.removals) {
-        buff.splice(at, qt);
-    }
-    for (const { from, to } of operations.swaps) {
-        const t = buff[to];
-        buff[to] = buff[from];
-        buff[from] = t;
-    }
-    for (const op of operations.inserts) {
-        buff.splice(op.at, 0, ...op.values);
-    }
-    return buff;
-}
-export function joinWithConjunction(arr, conjunction = ' and ', separator = ', ') {
-    if (arr.length === 0)
-        return '';
-    if (arr.length === 1)
-        return String(arr[0]);
-    return `${arr.slice(0, -1).join(separator)}${conjunction}${String(arr[arr.length - 1])}`;
-}

package/dist/async-result.d.ts

@@ -1,37 +0,0 @@
-export interface Idle {
-    type: 'idle';
-}
-export interface Loading {
-    type: 'loading';
-}
-export interface Success<V> {
-    type: 'success';
-    value: V;
-}
-export interface Failure<E> {
-    type: 'failure';
-    error: E;
-}
-export type AsyncResult<V, E> = Idle | Loading | Success<V> | Failure<E>;
-export declare const AsyncResult: {
-    idle: {
-        type: "idle";
-    };
-    loading: {
-        type: "loading";
-    };
-    success<V>(value: V): AsyncResult<V, never>;
-    failure<E>(error: E): AsyncResult<never, E>;
-    isSuccess<V_1, E_1>(r: AsyncResult<V_1, E_1>): r is Success<V_1>;
-    isFailure<V_2, E_2>(r: AsyncResult<V_2, E_2>): r is Failure<E_2>;
-    isIdle<V_3, E_3>(r: AsyncResult<V_3, E_3>): r is Idle;
-    isLoading<V_4, E_4>(r: AsyncResult<V_4, E_4>): r is Loading;
-    getOrElse<V_5, E_5>(r: AsyncResult<V_5, E_5>, alt: V_5): V_5;
-    getOrElseLazy<V_6, E_6>(r: AsyncResult<V_6, E_6>, altf: () => V_6): V_6;
-    getOrNull<V_7, E_7>(r: AsyncResult<V_7, E_7>): V_7 | null;
-    getOrUndefined<V_8, E_8>(r: AsyncResult<V_8, E_8>): V_8 | undefined;
-    cmatch: <V1, V2, E_9>(success: (value: V1) => V2, failure: (error: E_9) => V2, loading: () => V2, idle?: () => V2) => (r: AsyncResult<V1, E_9>) => V2;
-    match: <V1_1, V2_1, E_10>(r: AsyncResult<V1_1, E_10>, success: (value: V1_1) => V2_1, failure: (error: E_10) => V2_1, loading: () => V2_1, idle?: () => V2_1) => V2_1;
-    whenSuccess: <V_9, E_11>(apply: (v: V_9) => void) => (r: AsyncResult<V_9, E_11>) => AsyncResult<V_9, E_11>;
-    whenFailure: <V_10, E_12>(apply: (e: E_12) => void) => (r: AsyncResult<V_10, E_12>) => AsyncResult<V_10, E_12>;
-};

package/dist/async-result.js

@@ -1,75 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const AsyncResult = {
-    idle: { type: 'idle' },
-    loading: { type: 'loading' },
-    success(value) {
-        return { type: 'success', value };
-    },
-    failure(error) {
-        return { type: 'failure', error };
-    },
-    isSuccess(r) {
-        return r.type === 'success';
-    },
-    isFailure(r) {
-        return r.type === 'failure';
-    },
-    isIdle(r) {
-        return r.type === 'idle';
-    },
-    isLoading(r) {
-        return r.type === 'loading';
-    },
-    getOrElse(r, alt) {
-        return AsyncResult.isSuccess(r) ? r.value : alt;
-    },
-    getOrElseLazy(r, altf) {
-        return AsyncResult.isSuccess(r) ? r.value : altf();
-    },
-    getOrNull(r) {
-        return AsyncResult.isSuccess(r) ? r.value : null;
-    },
-    getOrUndefined(r) {
-        return AsyncResult.isSuccess(r) ? r.value : undefined;
-    },
-    cmatch: (success, failure, loading, idle = loading) => (r) => {
-        if (AsyncResult.isSuccess(r)) {
-            return success(r.value);
-        }
-        else if (AsyncResult.isFailure(r)) {
-            return failure(r.error);
-        }
-        else if (AsyncResult.isIdle(r)) {
-            return idle();
-        }
-        else {
-            return loading();
-        }
-    },
-    match: (r, success, failure, loading, idle = loading) => {
-        if (AsyncResult.isSuccess(r)) {
-            return success(r.value);
-        }
-        else if (AsyncResult.isFailure(r)) {
-            return failure(r.error);
-        }
-        else if (AsyncResult.isIdle(r)) {
-            return idle();
-        }
-        else {
-            return loading();
-        }
-    },
-    whenSuccess: (apply) => (r) => {
-        if (AsyncResult.isSuccess(r)) {
-            apply(r.value);
-        }
-        return r;
-    },
-    whenFailure: (apply) => (r) => {
-        if (AsyncResult.isFailure(r)) {
-            apply(r.error);
-        }
-        return r;
-    }
-};

package/dist/bigint.d.ts

@@ -1,18 +0,0 @@
-export declare function ceilDiv(x: bigint, y: bigint): bigint;
-export declare function floorDiv(x: bigint, y: bigint): bigint;
-export declare function compare(x: bigint, y: bigint): number;
-export declare function abs(x: bigint): bigint;
-export declare function min(x: bigint, y: bigint): bigint;
-export declare function max(x: bigint, y: bigint): bigint;
-export declare function pow(x: bigint, y: bigint): bigint;
-export declare function gcd(x: bigint, y: bigint): bigint;
-export declare function lcm(x: bigint, y: bigint): bigint;
-export declare function isPrime(x: bigint): boolean;
-export declare function nextPrime(x: bigint): bigint;
-export declare function prevPrime(x: bigint): bigint;
-export declare function isEven(x: bigint): boolean;
-export declare function isOdd(x: bigint): boolean;
-export declare function isZero(x: bigint): boolean;
-export declare function isOne(x: bigint): boolean;
-export declare function isNegative(x: bigint): boolean;
-export declare function isPositive(x: bigint): boolean;

package/dist/bigint.js

@@ -1,110 +0,0 @@
-export function ceilDiv(x, y) {
-    if (y < 0n) {
-        x = -x;
-        y = -y;
-    }
-    return x <= 0n ? x / y : (x - 1n) / y + 1n;
-}
-export function floorDiv(x, y) {
-    if (y < 0n) {
-        x = -x;
-        y = -y;
-    }
-    return x >= 0n ? x / y : (x + 1n) / y - 1n;
-}
-export function compare(x, y) {
-    return x < y ? -1 : x > y ? 1 : 0;
-}
-export function abs(x) {
-    return x < 0n ? -x : x;
-}
-export function min(x, y) {
-    return x < y ? x : y;
-}
-export function max(x, y) {
-    return x > y ? x : y;
-}
-export function pow(x, y) {
-    if (y < 0n)
-        throw new Error('negative exponent');
-    let result = 1n;
-    while (y > 0n) {
-        if ((y & 1n) !== 0n)
-            result *= x;
-        y >>= 1n;
-        x *= x;
-    }
-    return result;
-}
-export function gcd(x, y) {
-    x = abs(x);
-    y = abs(y);
-    while (y > 0n) {
-        const t = y;
-        y = x % y;
-        x = t;
-    }
-    return x;
-}
-export function lcm(x, y) {
-    return abs(x * y) / gcd(x, y);
-}
-export function isPrime(x) {
-    if (x < 2n)
-        return false;
-    if (x === 2n || x === 3n)
-        return true;
-    if (x % 2n === 0n || x % 3n === 0n)
-        return false;
-    let i = 5n;
-    while (i * i <= x) {
-        if (x % i === 0n || x % (i + 2n) === 0n)
-            return false;
-        i += 6n;
-    }
-    return true;
-}
-export function nextPrime(x) {
-    if (x < 2n)
-        return 2n;
-    if (x === 2n)
-        return 3n;
-    if (x % 2n === 0n)
-        x++;
-    else
-        x += 2n;
-    while (!isPrime(x))
-        x += 2n;
-    return x;
-}
-export function prevPrime(x) {
-    if (x <= 2n)
-        throw new Error('no previous prime');
-    if (x === 3n)
-        return 2n;
-    if (x % 2n === 0n)
-        x--;
-    else
-        x -= 2n;
-    while (!isPrime(x))
-        x -= 2n;
-    return x;
-}
-export function isEven(x) {
-    return x % 2n === 0n;
-}
-export function isOdd(x) {
-    return x % 2n !== 0n;
-}
-export function isZero(x) {
-    return x === 0n;
-}
-export function isOne(x) {
-    return x === 1n;
-}
-export function isNegative(x) {
-    return x < 0n;
-}
-export function isPositive(x) {
-    return x > 0n;
-}

package/dist/booleans.d.ts

@@ -1,23 +0,0 @@
-/**
- * Utility functions to manipulate `boolean` values.
- */
-/**
- * Returns a comparison value (`Int`) from two boolean values.
- */
-export declare function compare(a: boolean, b: boolean): number;
-/**
- * Converts a boolean to an integer value (`true` => `1`, `false` => `0`).
- */
-export declare function toInt(v: boolean): number;
-/**
- * Returns `true` if the passed value is either `true` or `false` (case insensitive).
- */
-export declare function canParse(v: string): boolean;
-/**
- * Returns `true`/`false` if the passed value is `true`/`false` (case insensitive) with any other value it will return null.
- */
-export declare function parse(v: string): boolean;
-/**
- * Returns `true` when arguments are different.
- */
-export declare function xor(a: boolean, b: boolean): boolean;

package/dist/booleans.js

@@ -1,68 +0,0 @@
-/*
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    https://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-/**
- * Utility functions to manipulate `boolean` values.
- */
-/**
- * Returns a comparison value (`Int`) from two boolean values.
- */
-export function compare(a, b) {
-    return a === b ? 0 : a ? -1 : 1;
-}
-/**
- * Converts a boolean to an integer value (`true` => `1`, `false` => `0`).
- */
-export function toInt(v) {
-    return v ? 1 : 0;
-}
-/**
- * Returns `true` if the passed value is either `true` or `false` (case insensitive).
- */
-export function canParse(v) {
-    if (v == null)
-        return false;
-    switch (v.toLowerCase()) {
-        case 'true':
-        case 'false':
-        case '0':
-        case '1':
-        case 'on':
-        case 'off':
-            return true;
-        default:
-            return false;
-    }
-}
-/**
- * Returns `true`/`false` if the passed value is `true`/`false` (case insensitive) with any other value it will return null.
- */
-export function parse(v) {
-    switch (v.toLowerCase()) {
-        case 'true':
-        case '1':
-        case 'on':
-            return true;
-        case 'false':
-        case '0':
-        case 'off':
-            return false;
-        default:
-            throw new Error(`unable to parse '${v}'`);
-    }
-}
-/**
- * Returns `true` when arguments are different.
- */
-export function xor(a, b) {
-    return a !== b;
-}

package/dist/colors/cmyk.d.ts

@@ -1,21 +0,0 @@
-export declare class CMYK {
-    static fromString(s: string): CMYK;
-    static ofChannels([cyan, magenta, yellow, black]: [
-        cyan: number,
-        magenta: number,
-        yellow: number,
-        black: number
-    ]): CMYK;
-    readonly cyan: number;
-    readonly magenta: number;
-    readonly yellow: number;
-    readonly black: number;
-    constructor(cyan: number, magenta: number, yellow: number, black: number);
-    withCyan(cyan: number): CMYK;
-    withMagenta(magenta: number): CMYK;
-    withYellow(yellow: number): CMYK;
-    withBlack(black: number): CMYK;
-    toChannels(): [number, number, number, number];
-    toString(): string;
-    equals(other: CMYK, tollerance?: number): boolean;
-}