@tempots/std 0.9.5 → 0.9.7

package/colors/srgb.js

@@ -0,0 +1,51 @@
+import { clamp, nearEquals } from '../numbers';
+const TOLLERANCE = 0.001;
+export class SRGB {
+    static fromString(s) {
+        const m = s.match(/^rgb\((\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%, ?(\d+(?:\.\d+)?)%\)$/);
+        if (m != null) {
+            const [, red, blue, green] = m;
+            return new SRGB(parseFloat(red), parseFloat(blue), parseFloat(green));
+        }
+        else {
+            throw new Error(`Invalid RGB string: ${s}`);
+        }
+    }
+    static ofChannels([red, blue, green]) {
+        return new SRGB(clamp(red * 100, 0, 100), clamp(blue * 100, 0, 100), clamp(green * 100, 0, 100));
+    }
+    red;
+    blue;
+    green;
+    /**
+     *
+     * @param red Percentage (0-100)
+     * @param blue Percentage (0-100)
+     * @param green Percentage (0-100)
+     */
+    constructor(red, blue, green) {
+        this.red = clamp(red, 0, 100);
+        this.blue = clamp(blue, 0, 100);
+        this.green = clamp(green, 0, 100);
+    }
+    withRed(red) {
+        return new SRGB(red, this.blue, this.green);
+    }
+    withBlue(blue) {
+        return new SRGB(this.red, blue, this.green);
+    }
+    withGreen(green) {
+        return new SRGB(this.red, this.blue, green);
+    }
+    toString() {
+        return `rgb(${this.red}%, ${this.blue}%, ${this.green}%)`;
+    }
+    toChannels() {
+        return [this.red / 100, this.blue / 100, this.green / 100];
+    }
+    equals(other, tollerance = TOLLERANCE) {
+        return (nearEquals(this.red, other.red, tollerance) &&
+            nearEquals(this.blue, other.blue, tollerance) &&
+            nearEquals(this.green, other.green, tollerance));
+    }
+}

package/colors/xyz.d.ts

@@ -0,0 +1,19 @@
+export declare class XYZ {
+    static ofChannels([x, y, z]: [x: number, y: number, z: number]): XYZ;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    /**
+     *
+     * @param x
+     * @param y 100 is the brightest white
+     * @param z
+     */
+    constructor(x: number, y: number, z: number);
+    withX(x: number): XYZ;
+    withY(y: number): XYZ;
+    withZ(z: number): XYZ;
+    toString(): string;
+    toChannels(): [number, number, number];
+    equals(other: XYZ, tollerance?: number): boolean;
+}

package/colors/xyz.js

@@ -0,0 +1,41 @@
+import { nearEquals } from '../numbers';
+const TOLLERANCE = 0.0001;
+export class XYZ {
+    static ofChannels([x, y, z]) {
+        return new XYZ(x, y, z);
+    }
+    x;
+    y;
+    z;
+    /**
+     *
+     * @param x
+     * @param y 100 is the brightest white
+     * @param z
+     */
+    constructor(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    withX(x) {
+        return new XYZ(x, this.y, this.z);
+    }
+    withY(y) {
+        return new XYZ(this.x, y, this.z);
+    }
+    withZ(z) {
+        return new XYZ(this.x, this.y, z);
+    }
+    toString() {
+        return `XYZ(${this.x}, ${this.y}, ${this.z})`;
+    }
+    toChannels() {
+        return [this.x, this.y, this.z];
+    }
+    equals(other, tollerance = TOLLERANCE) {
+        return (nearEquals(this.x, other.x, tollerance) &&
+            nearEquals(this.y, other.y, tollerance) &&
+            nearEquals(this.z, other.z, tollerance));
+    }
+}

package/edit.d.ts

@@ -0,0 +1,20 @@
+export declare abstract class Edit<V, I, E> {
+    abstract readonly type: 'Input' | 'Error' | 'Value';
+}
+export declare class Input<I> extends Edit<never, I, never> {
+    readonly input: I;
+    readonly type: "Input";
+    constructor(input: I);
+}
+export declare class Error<I, E> extends Edit<never, I, E> {
+    readonly input: I;
+    readonly error: E;
+    readonly type: "Error";
+    constructor(input: I, error: E);
+}
+export declare class Value<V> extends Edit<V, never, never> {
+    readonly value: V;
+    readonly type: "Value";
+    constructor(value: V);
+}
+export type Validate<V, I, E> = (input: Input<I> | Error<I, E>) => Error<I, E> | Value<V>;

package/edit.js

@@ -0,0 +1,29 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export class Edit {
+}
+export class Input extends Edit {
+    input;
+    type = 'Input';
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+}
+export class Error extends Edit {
+    input;
+    error;
+    type = 'Error';
+    constructor(input, error) {
+        super();
+        this.input = input;
+        this.error = error;
+    }
+}
+export class Value extends Edit {
+    value;
+    type = 'Value';
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+}

package/equals.d.ts

@@ -0,0 +1,3 @@
+export declare function strictEqual<A>(a: A, b: A): boolean;
+export declare function deepEqual<A>(a: A, b: A): boolean;
+export declare function looseEqual<T>(a: T, b: T): boolean;

package/equals.js

@@ -0,0 +1,122 @@
+/*
+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.
+*/
+export function strictEqual(a, b) {
+    // eslint-disable-next-line no-self-compare
+    return a === b || (a !== a && b !== b);
+}
+export function deepEqual(a, b) {
+    if (strictEqual(a, b))
+        return true;
+    if (a == null || b == null)
+        return false;
+    const aIsArr = Array.isArray(a);
+    const bIsArr = Array.isArray(b);
+    if (aIsArr !== bIsArr)
+        return false;
+    if (aIsArr) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const aArr = a;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const bArr = b;
+        const aLength = aArr.length;
+        if (aLength !== bArr.length)
+            return false;
+        for (let i = 0; i < aLength; i++) {
+            if (!deepEqual(aArr[i], bArr[i]))
+                return false;
+        }
+        return true;
+    }
+    const aIsDate = a instanceof Date;
+    const bIsDate = b instanceof Date;
+    if (aIsDate !== bIsDate)
+        return false;
+    if (aIsDate) {
+        const aDate = a;
+        const bDate = b;
+        return +aDate === +bDate;
+    }
+    const aIsSet = a instanceof Set;
+    const bIsSet = b instanceof Set;
+    if (aIsSet !== bIsSet)
+        return false;
+    if (aIsSet) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const aSet = a;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const bSet = b;
+        if (aSet.size !== bSet.size)
+            return false;
+        const it = aSet.keys();
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const curr = it.next();
+            if (curr.done ?? false)
+                break;
+            if (!bSet.has(curr.value))
+                return false;
+        }
+        return true;
+    }
+    const aIsMap = a instanceof Map;
+    const bIsMap = b instanceof Map;
+    if (aIsMap !== bIsMap)
+        return false;
+    if (aIsMap) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const aMap = a;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const bMap = b;
+        const aMapLength = aMap.size;
+        if (aMapLength !== bMap.size)
+            return false;
+        const it = aMap.keys();
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const curr = it.next();
+            if (curr.done ?? false)
+                break;
+            if (!deepEqual(aMap.get(curr.value), bMap.get(curr.value)))
+                return false;
+        }
+        return true;
+    }
+    const aIsObj = typeof a === 'object';
+    const bIsObj = typeof b === 'object';
+    if (aIsObj !== bIsObj)
+        return false;
+    if (aIsObj) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const aObj = a;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const bObj = b;
+        const aFields = Object.keys(aObj);
+        const bFields = Object.keys(bObj);
+        const aLength = aFields.length;
+        if (aLength !== bFields.length)
+            return false;
+        for (let i = 0; i < aLength; i++) {
+            const field = aFields[i];
+            if (!Object.prototype.hasOwnProperty.call(bObj, field))
+                return false;
+            if (!deepEqual(aObj[field], bObj[field]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+export function looseEqual(a, b) {
+    // eslint-disable-next-line eqeqeq
+    return a == b;
+}

package/functions.d.ts

@@ -0,0 +1,20 @@
+export declare function compose<A>(): (a: A) => A;
+export declare function compose<A, B>(f1: (a: A) => B): (a: A) => B;
+export declare function compose<A, B, C>(f1: (a: A) => B, f2: (b: B) => C): (a: A) => C;
+export declare function compose<A, B, C, D>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D): (a: A) => D;
+export declare function compose<A, B, C, D, E>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E): (a: A) => E;
+export declare function compose<A, B, C, D, E, F>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F): (a: A) => F;
+export declare function compose<A, B, C, D, E, F, G>(f1: (a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G): (a: A) => G;
+export declare function identity<T>(v: T): T;
+export declare function curryLeft<A, Rest extends any[], Ret>(f: (a: A, ...rest: Rest) => Ret): (a: A) => (...rest: Rest) => Ret;
+export declare function curryRight<A, B, C, D>(f: (a: A, b: B, c: C) => D): (a: A, b: B) => (c: C) => D;
+export declare function curryRight<A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E): (a: A, b: B, c: C) => (d: D) => E;
+export declare function curryRight<A, B, C, D, E, F>(f: (a: A, b: B, c: C, d: D, e: E) => F): (a: A, b: B, c: C, d: D) => (e: E) => F;
+export declare function curryRight<A, B, C, D, E, F, G>(f: (a: A, b: B, c: C, d: D, e: E, f: F) => G): (a: A, b: B, c: C, d: D, e: E) => (f: F) => G;
+export declare function flip<A, B, C>(f: (a: A, b: B) => C): (b: B, a: A) => C;
+export declare function flip<A, B, C, D>(f: (a: A, b: B, c: C) => D): (c: C, b: B, a: A) => D;
+export declare function flip<A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E): (d: D, c: C, b: B, a: A) => E;
+export declare function flip<A, B, C, D, E>(f: (a: A, b: B, c: C, d: D) => E): (d: D, c: C, b: B, a: A) => E;
+export declare function flip<A, B, C, D, E, F>(f: (a: A, b: B, c: C, d: D, e: E) => F): (e: E, d: D, c: C, b: B, a: A) => F;
+export declare function flip<A, B, C, D, E, F, G>(f: (a: A, b: B, c: C, d: D, e: E, f: F) => G): (f: F, e: E, d: D, c: C, b: B, a: A) => G;
+export declare function id<T>(v: T): T;

package/functions.js

@@ -0,0 +1,38 @@
+/*
+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.
+*/
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function compose(...args) {
+    return (a) => args.reduce((acc, f) => f(acc), a);
+}
+export function identity(v) {
+    return v;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function curryLeft(f) {
+    return (a) => (...rest) => f(a, ...rest);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function curryRight(f) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (...args) => 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (a) => f(...args.concat([a]));
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function flip(f) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (...args) => f(...args.reverse());
+}
+export function id(v) {
+    return v;
+}

package/json.d.ts

@@ -0,0 +1,14 @@
+import { Result } from './result';
+export type JSONPrimitive = string | boolean | number | null;
+export interface JSONObject {
+    [k: string]: JSONValue;
+}
+export type JSONArray = JSONValue[];
+export type JSONValue = JSONPrimitive | JSONObject | JSONArray;
+export declare function deserialize(s: string): Result<JSONValue, string>;
+export declare function makeSerializer(options: {
+    minified?: boolean;
+    whitelist?: string[];
+}): (v: JSONValue) => string;
+export declare function serialize(v: JSONValue): string;
+export declare function serializeMinified(v: JSONValue): string;

package/json.js

@@ -0,0 +1,33 @@
+/*
+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.
+*/
+import { Result } from './result';
+export function deserialize(s) {
+    try {
+        return Result.success(JSON.parse(s));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (e) {
+        return Result.failure(e.message);
+    }
+}
+export function makeSerializer(options) {
+    return function serialize(v) {
+        return JSON.stringify(v, options.whitelist, options.minified === false ? undefined : 2);
+    };
+}
+export function serialize(v) {
+    return JSON.stringify(v, null, 2);
+}
+export function serializeMinified(v) {
+    return JSON.stringify(v);
+}

package/match.d.ts

@@ -0,0 +1,16 @@
+import { type Differentiate, type DifferentiateAt } from './types/differentiate';
+import { type AnyKey } from './types/utility';
+import { type ObjectWithField, type ObjectWithPath, type TypeAtPath } from './types/objects';
+export declare function matchLiteral<A extends AnyKey, B>(input: A, matcher: {
+    [k in A]: B;
+}): B;
+export declare function match<F extends AnyKey, T extends ObjectWithField<F, any>, B>(input: T, field: F, matcher: {
+    [k in T[F]]: (arg: Differentiate<F, T, k>) => B;
+}): B;
+export declare function deepMatch<Path extends AnyKey[], T extends ObjectWithPath<Path, any>, B>(input: T, path: Path, matcher: {
+    [k in TypeAtPath<Path, T>]: (arg: DifferentiateAt<Path, T, k>) => B;
+}): B;
+export declare function createMatch<F extends AnyKey>(field: F): <T extends ObjectWithField<F, any>, B>(input: T, matcher: { [k in T[F]]: (arg: Differentiate<F, T, k>) => B; }) => B;
+export declare const createDeepMatch: <Path extends AnyKey[]>(...path: Path) => <T extends ObjectWithPath<Path, any>, B>(input: T, matcher: { [k in TypeAtPath<Path, T>]: (arg: DifferentiateAt<Path, T, k>) => B; }) => B;
+export declare const matchKind: <T extends ObjectWithField<"kind", any>, B>(input: T, matcher: { [k in T["kind"]]: (arg: Differentiate<"kind", T, k>) => B; }) => B;
+export declare const matchType: <T extends ObjectWithField<"type", any>, B>(input: T, matcher: { [k in T["type"]]: (arg: Differentiate<"type", T, k>) => B; }) => B;

package/match.js

@@ -0,0 +1,45 @@
+/*
+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.
+*/
+export function matchLiteral(input, matcher) {
+    return matcher[input];
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function match(input, field, matcher) {
+    const k = input[field];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return matcher[k](input);
+}
+export function deepMatch(input, path, matcher) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const k = path.reduce((res, key) => res[key], input);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return matcher[k](input);
+}
+export function createMatch(field) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (input, matcher) => {
+        const k = input[field];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return matcher[k](input);
+    };
+}
+export const createDeepMatch = (...path) => 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+(input, matcher) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const k = path.reduce((res, key) => res[key], input);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return matcher[k](input);
+};
+export const matchKind = createMatch('kind');
+export const matchType = createMatch('type');

package/maybe.d.ts

@@ -0,0 +1,9 @@
+export type Maybe<T> = Just<T> | Nothing;
+export type Nothing = undefined | null;
+export type Just<T> = T;
+export declare const Maybe: {
+    nothing: Maybe<never>;
+    just: <T>(value: T) => Maybe<T>;
+    isNothing: <T_1>(maybe: Maybe<T_1>) => maybe is Nothing;
+    isJust: <T_2>(maybe: Maybe<T_2>) => maybe is T_2;
+};

package/{src/maybe.ts → maybe.js}

@@ -10,23 +10,16 @@ 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.
 */
-
-export type Maybe<T> = Just<T> | Nothing
-
-export type Nothing = undefined | null
-export type Just<T> = T
-
 // eslint-disable-next-line @typescript-eslint/no-redeclare
 export const Maybe = {
-  nothing: undefined as Maybe<never>,
-  just: <T>(value: T): Maybe<T> => {
-    return value
-  },
-
-  isNothing: <T>(maybe: Maybe<T>): maybe is Nothing => {
-    return maybe == null
-  },
-  isJust: <T>(maybe: Maybe<T>): maybe is Just<T> => {
-    return maybe != null
-  }
-}
+    nothing: undefined,
+    just: (value) => {
+        return value;
+    },
+    isNothing: (maybe) => {
+        return maybe == null;
+    },
+    isJust: (maybe) => {
+        return maybe != null;
+    }
+};

package/memoize.d.ts

@@ -0,0 +1 @@
+export declare function memoize<T>(f: () => T): () => T;

package/memoize.js

@@ -0,0 +1,9 @@
+export function memoize(f) {
+    let value;
+    return () => {
+        if (value === undefined) {
+            value = f();
+        }
+        return value;
+    };
+}

package/newtype.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Usage:
+ *
+ * ```ts
+ * export interface Int extends Newtype<
+ *   number,
+ *   { readonly Int: unique symbol }
+ * > {}
+ *
+ * export const Int = new class extends NewtypeClass<Int> {
+ *   isValid(v: number) { return Number.isInteger(v) }
+ * }()
+ * ```
+ */
+import { type Maybe } from './maybe';
+export type TypeOfN<T extends Newtype<unknown, unknown>> = T['_T'];
+export interface Newtype<V, S> {
+    readonly _T: V;
+    readonly _S: S;
+}
+export declare abstract class NewtypeClass<T extends Newtype<unknown, unknown>> {
+    abstract isValid(v: TypeOfN<T>): boolean;
+    unsafeOf(v: TypeOfN<T>): T;
+    of(v: TypeOfN<T>): Maybe<T>;
+    get(v: T): TypeOfN<T>;
+    modify(f: (v: TypeOfN<T>) => TypeOfN<T>): (value: T) => Maybe<T>;
+    unsafeModify(f: (v: TypeOfN<T>) => TypeOfN<T>): (value: T) => T;
+}

package/newtype.js

@@ -0,0 +1,29 @@
+/*
+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.
+*/
+export class NewtypeClass {
+    unsafeOf(v) {
+        return v;
+    }
+    of(v) {
+        return this.isValid(v) ? v : undefined;
+    }
+    get(v) {
+        return v;
+    }
+    modify(f) {
+        return (value) => this.of(f(this.get(value)));
+    }
+    unsafeModify(f) {
+        return (value) => this.unsafeOf(f(this.get(value)));
+    }
+}