@davidsouther/jiffies 1.1.0 → 2.0.0

package/lib/esm/context.d.ts

@@ -0,0 +1,15 @@
+import { Err, Result } from "./result.js";
+export declare const Enter: unique symbol;
+export declare const Exit: unique symbol;
+export interface Context {
+    [Enter]: () => void;
+    [Exit]: () => void;
+}
+export interface Operation<T, E extends Error, C extends Context> {
+    (c: C): T | Result<T, E>;
+}
+export interface AsyncOperation<T, E extends Error, C extends Context> {
+    (c: C): Promise<T | Result<T, E>>;
+}
+export declare function using<T, E extends Error, C extends Context>(context: C | (() => C) | Operation<T, E, C>, operation?: Operation<T, E, C>, normalizeError?: (e: Error | unknown | any) => Err<E>): Result<T, E>;
+export declare function asyncUsing<T, E extends Error, C extends Context>(context: C | (() => Promise<C>), operation: AsyncOperation<T, E, C>, normalizeError?: (e: Error | unknown | any) => Err<E>): Promise<Result<T, E>>;

package/{build → lib/esm}/context.js

@@ -1,43 +1,43 @@
-import { Ok, Err, isResult } from "./result.js";
-export const Enter = Symbol("Context Enter");
-export const Exit = Symbol("Context Exit");
-export function using(context, operation, normalizeError = (e) => Err(e)) {
-    if (typeof context == "function") {
-        if (context.length == 1) {
-            operation = context;
-            context = {};
-        }
-        else {
-            context = context();
-        }
-    }
-    let result;
-    try {
-        context[Enter]();
-        const op = operation(context);
-        result = isResult(op) ? op : Ok(op);
-    }
-    catch (e) {
-        result = normalizeError(e);
-    }
-    finally {
-        context[Exit]();
-    }
-    return result;
-}
-export async function asyncUsing(context, operation, normalizeError = (e) => Err(e)) {
-    context = typeof context == "function" ? await context() : context;
-    let result;
-    try {
-        context[Enter]();
-        const op = await operation(context);
-        result = isResult(op) ? op : Ok(op);
-    }
-    catch (e) {
-        result = normalizeError(e);
-    }
-    finally {
-        context[Exit]();
-    }
-    return result;
-}
+import { Ok, Err, isResult } from "./result.js";
+export const Enter = Symbol("Context Enter");
+export const Exit = Symbol("Context Exit");
+export function using(context, operation, normalizeError = (e) => Err(e)) {
+    if (typeof context === "function") {
+        if (context.length === 1) {
+            operation = context;
+            context = {};
+        }
+        else {
+            context = context();
+        }
+    }
+    let result;
+    try {
+        context[Enter]();
+        const op = operation(context);
+        result = isResult(op) ? op : Ok(op);
+    }
+    catch (e) {
+        result = normalizeError(e);
+    }
+    finally {
+        context[Exit]();
+    }
+    return result;
+}
+export async function asyncUsing(context, operation, normalizeError = (e) => Err(e)) {
+    context = typeof context === "function" ? await context() : context;
+    let result;
+    try {
+        context[Enter]();
+        const op = await operation(context);
+        result = isResult(op) ? op : Ok(op);
+    }
+    catch (e) {
+        result = normalizeError(e);
+    }
+    finally {
+        context[Exit]();
+    }
+    return result;
+}

package/lib/esm/context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{build → lib/esm}/context.test.js

@@ -1,46 +1,46 @@
-import { Enter, Exit, using } from "./context.js";
-import { Err, isErr, isOk, Ok, unwrap } from "./result.js";
-import { describe, it } from "./scope/describe.js";
-import { expect } from "./scope/expect.js";
-describe("Context", () => {
-    it("performs an operation using a context", () => {
-        const context = TestContext();
-        const result = using(context, () => Ok(5));
-        expect(unwrap(result)).toBe(5);
-        expect(context.initialized).toBe(true);
-        expect(context.completed).toBe(true);
-    });
-    it("reports the result of a thrown error", () => {
-        const context = TestContext();
-        const result = using(context, () => {
-            throw new Error("Failed");
-        });
-        expect(isErr(result)).toBe(true);
-        expect(Err(result)).toMatchObject({
-            message: "Failed",
-        });
-    });
-    it("passes the context to the operation", () => {
-        const op = using(TestContext, ({ initialized, completed }) => ({
-            initialized,
-            completed,
-        }));
-        expect(isOk(op)).toBe(true);
-        const { completed, initialized } = unwrap(op);
-        expect(initialized).toBe(true);
-        expect(completed).toBe(false);
-    });
-});
-function TestContext() {
-    const context = {
-        [Enter]: () => {
-            context.initialized = true;
-        },
-        [Exit]: () => {
-            context.completed = true;
-        },
-        initialized: false,
-        completed: false,
-    };
-    return context;
-}
+import { Enter, Exit, using } from "./context.js";
+import { Err, isErr, isOk, Ok, unwrap } from "./result.js";
+import { describe, it } from "./scope/describe.js";
+import { expect } from "./scope/expect.js";
+describe("Context", () => {
+    it("performs an operation using a context", () => {
+        const context = TestContext();
+        const result = using(context, () => Ok(5));
+        expect(unwrap(result)).toBe(5);
+        expect(context.initialized).toBe(true);
+        expect(context.completed).toBe(true);
+    });
+    it("reports the result of a thrown error", () => {
+        const context = TestContext();
+        const result = using(context, () => {
+            throw new Error("Failed");
+        });
+        expect(isErr(result)).toBe(true);
+        expect(Err(result)).toMatchObject({
+            message: "Failed",
+        });
+    });
+    it("passes the context to the operation", () => {
+        const op = using(TestContext, ({ initialized, completed }) => ({
+            initialized,
+            completed,
+        }));
+        expect(isOk(op)).toBe(true);
+        const { completed, initialized } = unwrap(op);
+        expect(initialized).toBe(true);
+        expect(completed).toBe(false);
+    });
+});
+function TestContext() {
+    const context = {
+        [Enter]: () => {
+            context.initialized = true;
+        },
+        [Exit]: () => {
+            context.completed = true;
+        },
+        initialized: false,
+        completed: false,
+    };
+    return context;
+}

package/lib/esm/debounce.d.ts

@@ -0,0 +1 @@
+export declare function debounce(fn: (...args: any[]) => any, ms?: number): (...args: Parameters<typeof fn>) => ReturnType<typeof fn>;

package/{build → lib/esm}/debounce.js

@@ -1,7 +1,7 @@
-export function debounce(fn, ms = 32) {
-    let timer;
-    return (...args) => {
-        clearTimeout(timer);
-        timer = setTimeout(() => (clearTimeout(timer), fn(...args)), ms);
-    };
-}
+export function debounce(fn, ms = 32) {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => (clearTimeout(timer), fn(...args)), ms);
+    };
+}

package/lib/esm/diff.d.ts

@@ -0,0 +1,15 @@
+export declare const DiffA: unique symbol;
+export declare const DiffB: unique symbol;
+export declare type DiffIndex = string | number;
+export declare type DiffPrimitive = string | number | boolean | null | undefined;
+interface DiffEntry {
+    key: DiffIndex;
+    left: DiffPrimitive;
+    right: DiffPrimitive;
+}
+interface DiffList {
+    key: DiffIndex;
+    children: (DiffEntry | DiffList)[];
+}
+export declare function diff<T>(a: Partial<T>, b: Partial<T>): (DiffEntry | DiffList)[];
+export {};

package/lib/esm/diff.js

@@ -0,0 +1,54 @@
+import { range } from "./range.js";
+import { isSome, None, Some } from "./result.js";
+export const DiffA = Symbol("A");
+export const DiffB = Symbol("B");
+function doDiff(va, vb, k) {
+    if (Array.isArray(va)) {
+        // @ts-ignore
+        return diffArray(va, vb, k);
+    }
+    if (typeof va === "object") {
+        const d = diffObject(va, vb, k);
+        if (d.children.length === 0) {
+            return None();
+        }
+        else {
+            return Some(d);
+        }
+    }
+    if (Object.is(va, vb)) {
+        return None();
+    }
+    else {
+        // @ts-ignore
+        return { key: k, left: va, right: vb };
+    }
+}
+function diffArray(a, b, key) {
+    const indexes = Math.max(a.length, b.length);
+    const children = range(0, indexes)
+        .map((i) => doDiff(a[i], b[i], i))
+        .filter(isSome);
+    return children.length > 0 ? { key, children } : None();
+}
+function diffObject(a, b, key = "") {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    const children = [...keys]
+        // @ts-ignore
+        .map((k) => doDiff(a[k], b[k], k))
+        .filter(isSome);
+    return {
+        key,
+        children,
+    };
+}
+export function diff(a, b) {
+    if (typeof a != "object" && !Object.is(a, b)) {
+        // @ts-ignore
+        return [{ key: "", left: a, right: b }];
+    }
+    return (Array.isArray(a)
+        ? // @ts-ignore
+            diffArray(a, b, "") ?? { children: [] }
+        : diffObject(a, b, "")).children;
+}

package/lib/esm/diff.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/diff.test.js

@@ -0,0 +1,39 @@
+import { diff } from "./diff.js";
+import { describe, it } from "./scope/describe.js";
+import { expect } from "./scope/expect.js";
+describe("diff", () => {
+    it("diffs primitives", () => {
+        const diffed = diff(1, 2);
+        expect(diffed).toEqual([{ key: "", left: 1, right: 2 }]);
+    });
+    it("diffs objects", () => {
+        const diffed = diff({ a: 1, b: 2 }, { a: 2, b: 2 });
+        expect(diffed).toEqual([{ key: "a", left: 1, right: 2 }]);
+    });
+    it("diffs nested objects", () => {
+        const diffed = diff({ a: { c: 1 }, b: 2 }, { a: { c: 2 }, b: 2 });
+        expect(diffed).toEqual([
+            { key: "a", children: [{ key: "c", left: 1, right: 2 }] },
+        ]);
+    });
+    it("diffs missing sides", () => {
+        const diffed = diff({ a: 1 }, { b: 2 });
+        expect(diffed).toEqual([
+            { key: "a", left: 1, right: undefined },
+            { key: "b", left: undefined, right: 2 },
+        ]);
+    });
+    it("diffs arrays", () => {
+        const diffed = diff([1, 2, 3], [1, 4, 3]);
+        expect(diffed).toEqual([{ key: 1, left: 2, right: 4 }]);
+    });
+    it("diffs objects in an array", () => {
+        const diffed = diff([{ a: { b: 1 } }, { a: { b: 2 } }, { a: { b: 3 } }], [{ a: { b: 1 } }, { a: { b: 4 } }, { a: { b: 3 } }]);
+        expect(diffed).toEqual([
+            {
+                key: 1,
+                children: [{ key: "a", children: [{ key: "b", left: 2, right: 4 }] }],
+            },
+        ]);
+    });
+});

package/lib/esm/display.d.ts

@@ -0,0 +1,5 @@
+export declare type Display = string | {
+    toString(): string;
+};
+export declare const isDisplay: (a: unknown) => a is Display;
+export declare const display: (a: unknown | Display) => string;

package/{build → lib/esm}/display.js

@@ -1,11 +1,11 @@
-export const isDisplay = (/** @type unknown */ a) => typeof a.toString === "function" ||
-    typeof a === "string";
-export const display = (a) => {
-    if (isDisplay(a)) {
-        const str = a.toString();
-        if (str === "[object Object]")
-            return JSON.stringify(a);
-        return str;
-    }
-    return JSON.stringify(a);
-};
+export const isDisplay = (/** @type unknown */ a) => typeof a.toString === "function" ||
+    typeof a === "string";
+export const display = (a) => {
+    if (isDisplay(a)) {
+        const str = a.toString();
+        if (str === "[object Object]")
+            return JSON.stringify(a);
+        return str;
+    }
+    return JSON.stringify(a);
+};

package/lib/esm/dom/css/border.d.ts

@@ -0,0 +1,11 @@
+import { Properties } from "../types/css.js";
+import { Side, Size } from "./constants.js";
+export declare function rounded(size?: Size, side?: Side): Properties<0 | (string & {}), string & {}>;
+export declare function border({ side, style, radius, width, color, }: {
+    side?: Side;
+    style?: "solid" | "dotted" | "dashed" | "double" | "none";
+    radius?: Size;
+    width?: 0 | 1 | 2 | 4 | 8;
+    color?: string;
+}): {};
+export declare function inset(width: 0 | 1 | 2 | 4 | 8, color1?: string, color2?: string): {};

package/{build → lib/esm}/dom/css/border.js

@@ -1,27 +1,27 @@
-import { isSide, getSize, getSide } from "./core.js";
-export function rounded(size = "", side = "") {
-    if (isSide(size)) {
-        side = size;
-        size = "";
-    }
-    const sized = getSize(size);
-    return getSide(side).reduce((prev, curr) => {
-        if (curr === "") {
-            prev.borderRadius = sized;
-        }
-        else {
-            // @ts-ignore
-            prev[`border${curr}Radius`] = sized;
-        }
-        return prev;
-    }, {});
-}
-export function border({ side = "", style = "solid", radius = "", width = 1, color = "black", }) {
-    return {};
-}
-export function inset(width, color1 = "gray", color2 = "lightgray") {
-    return {
-        ...border({ side: "tl", width, color: color1, radius: "none" }),
-        ...border({ side: "br", width, color: color2, radius: "none" }),
-    };
-}
+import { isSide, getSize, getSide } from "./core.js";
+export function rounded(size = "", side = "") {
+    if (isSide(size)) {
+        side = size;
+        size = "";
+    }
+    const sized = getSize(size);
+    return getSide(side).reduce((prev, curr) => {
+        if (curr === "") {
+            prev.borderRadius = sized;
+        }
+        else {
+            // @ts-ignore
+            prev[`border${curr}Radius`] = sized;
+        }
+        return prev;
+    }, {});
+}
+export function border({ side = "", style = "solid", radius = "", width = 1, color = "black", }) {
+    return {};
+}
+export function inset(width, color1 = "gray", color2 = "lightgray") {
+    return {
+        ...border({ side: "tl", width, color: color1, radius: "none" }),
+        ...border({ side: "br", width, color: color2, radius: "none" }),
+    };
+}

package/lib/esm/dom/css/constants.d.ts

@@ -0,0 +1,31 @@
+export declare const Sizes: {
+    none: string;
+    sm: string;
+    "": string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    "3xl": string;
+    full: string;
+};
+export declare const Sides: {
+    "": string;
+    t: string;
+    r: string;
+    l: string;
+    b: string;
+    tl: string;
+    tr: string;
+    bl: string;
+    br: string;
+};
+export declare const Widths: {
+    "1/4": string;
+    "1/2": string;
+    "3/4": string;
+    full: string;
+};
+export declare type Size = keyof typeof Sizes;
+export declare type Side = keyof typeof Sides;
+export declare type Width = keyof typeof Widths;

package/{build → lib/esm}/dom/css/constants.js

@@ -1,28 +1,28 @@
-export const Sizes = {
-    none: "0px",
-    sm: "0.125rem",
-    "": "0.25rem",
-    md: "0.375rem",
-    lg: "0.5rem",
-    xl: "0.75rem",
-    "2xl": "1rem",
-    "3xl": "1.5rem",
-    full: "9999px",
-};
-export const Sides = {
-    "": "",
-    t: "Top",
-    r: "Right",
-    l: "Left",
-    b: "Bottom",
-    tl: "TopLeft",
-    tr: "TopRight",
-    bl: "BottomLeft",
-    br: "BottomRight",
-};
-export const Widths = {
-    "1/4": "25%",
-    "1/2": "50%",
-    "3/4": "75%",
-    full: "100%",
-};
+export const Sizes = {
+    none: "0px",
+    sm: "0.125rem",
+    "": "0.25rem",
+    md: "0.375rem",
+    lg: "0.5rem",
+    xl: "0.75rem",
+    "2xl": "1rem",
+    "3xl": "1.5rem",
+    full: "9999px",
+};
+export const Sides = {
+    "": "",
+    t: "Top",
+    r: "Right",
+    l: "Left",
+    b: "Bottom",
+    tl: "TopLeft",
+    tr: "TopRight",
+    bl: "BottomLeft",
+    br: "BottomRight",
+};
+export const Widths = {
+    "1/4": "25%",
+    "1/2": "50%",
+    "3/4": "75%",
+    full: "100%",
+};

package/lib/esm/dom/css/core.d.ts

@@ -0,0 +1,5 @@
+import { Side, Size, Sizes } from "./constants.js";
+export declare function isSide(v: string): v is Side;
+export declare function isSize(v: string): v is Size;
+export declare function getSize(size: keyof typeof Sizes): string;
+export declare function getSide(side: Side): string[];

package/{build → lib/esm}/dom/css/core.js

@@ -1,24 +1,24 @@
-import { Sides, Sizes } from "./constants.js";
-export function isSide(v) {
-    return Sides[v] !== undefined;
-}
-export function isSize(v) {
-    return Sizes[v] !== undefined;
-}
-export function getSize(size) {
-    return Sizes[size];
-}
-export function getSide(side) {
-    switch (side) {
-        case "t":
-            return [...getSide("tl"), ...getSide("tr")];
-        case "r":
-            return [...getSide("tr"), ...getSide("br")];
-        case "b":
-            return [...getSide("br"), ...getSide("bl")];
-        case "l":
-            return [...getSide("tl"), ...getSide("bl")];
-        default:
-            return [Sides[side]];
-    }
-}
+import { Sides, Sizes } from "./constants.js";
+export function isSide(v) {
+    return Sides[v] !== undefined;
+}
+export function isSize(v) {
+    return Sizes[v] !== undefined;
+}
+export function getSize(size) {
+    return Sizes[size];
+}
+export function getSide(side) {
+    switch (side) {
+        case "t":
+            return [...getSide("tl"), ...getSide("tr")];
+        case "r":
+            return [...getSide("tr"), ...getSide("br")];
+        case "b":
+            return [...getSide("br"), ...getSide("bl")];
+        case "l":
+            return [...getSide("tl"), ...getSide("bl")];
+        default:
+            return [Sides[side]];
+    }
+}

package/lib/esm/dom/css/fstyle.d.ts

@@ -0,0 +1,5 @@
+import { Properties } from "../types/css.js";
+export declare type FStyle = Properties | {
+    [k: string]: FStyle;
+};
+export declare function compileFStyle(fstyle: FStyle, prefix?: string): string;

package/{build → lib/esm}/dom/css/fstyle.js

@@ -1,32 +1,32 @@
-import { dashCase } from "../../case.js";
-export function compileFStyle(fstyle, prefix = "") {
-    const properties = [];
-    const rules = [];
-    for (const [key, value] of Object.entries(fstyle)) {
-        if (typeof value == "string") {
-            properties.push({ key, value });
-        }
-        else {
-            rules.push({ key, value });
-        }
-    }
-    let rule = "";
-    if (properties.length > 0) {
-        rule += `${prefix} {\n`;
-        for (const { key, value } of properties) {
-            rule += `  ${dashCase(key)}: ${value};\n`;
-        }
-        rule += "}\n\n";
-    }
-    for (const { key, value } of rules) {
-        if (key.startsWith("@media")) {
-            rule += `${key} {\n`;
-            rule += compileFStyle(value, "  ");
-            rule += `}\n\n`;
-        }
-        else {
-            rule += compileFStyle(value, `${prefix} ${key}`);
-        }
-    }
-    return rule;
-}
+import { dashCase } from "../../case.js";
+export function compileFStyle(fstyle, prefix = "") {
+    const properties = [];
+    const rules = [];
+    for (const [key, value] of Object.entries(fstyle)) {
+        if (typeof value == "string") {
+            properties.push({ key, value });
+        }
+        else {
+            rules.push({ key, value });
+        }
+    }
+    let rule = "";
+    if (properties.length > 0) {
+        rule += `${prefix} {\n`;
+        for (const { key, value } of properties) {
+            rule += `  ${dashCase(key)}: ${value};\n`;
+        }
+        rule += "}\n\n";
+    }
+    for (const { key, value } of rules) {
+        if (key.startsWith("@media")) {
+            rule += `${key} {\n`;
+            rule += compileFStyle(value, "  ");
+            rule += `}\n\n`;
+        }
+        else {
+            rule += compileFStyle(value, `${prefix} ${key}`);
+        }
+    }
+    return rule;
+}

package/lib/esm/dom/css/sizing.d.ts

@@ -0,0 +1,5 @@
+import { Width } from "./constants.js";
+export declare function width(amount: Width, block?: "inline"): {
+    width: string;
+    display?: string | undefined;
+};