@casekit/toolbox 0.0.0-20250322230249

package/build/index.d.ts

@@ -0,0 +1,6 @@
+export { interleave } from "./interleave.js";
+export { notNull } from "./notNull.js";
+export { toSentence } from "./toSentence.js";
+export type { Conform } from "./types/Conform.js";
+export type { MarkNonNullable } from "./types/MarkNonNullable.js";
+export type { Simplify } from "./types/Simplify.js";

package/build/index.js

@@ -0,0 +1,5 @@
+/* v8 ignore start */
+export { interleave } from "./interleave.js";
+export { notNull } from "./notNull.js";
+export { toSentence } from "./toSentence.js";
+/* v8 ignore stop */

package/build/interleave.d.ts

@@ -0,0 +1 @@
+export declare const interleave: <T, U>(xs: T[], y: U) => (T | U)[];

package/build/interleave.js

@@ -0,0 +1,9 @@
+export const interleave = (xs, y) => {
+    const zs = [];
+    xs.forEach((x, index) => {
+        zs.push(x);
+        if (index < xs.length - 1)
+            zs.push(y);
+    });
+    return zs;
+};

package/build/interleave.test.d.ts

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

package/build/interleave.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "vitest";
+import { interleave } from "#interleave.js";
+describe("interleave", () => {
+    test("it interleaves a value between elements of a list", () => {
+        expect(interleave([1, 2, 3], "x")).toEqual([1, "x", 2, "x", 3]);
+    });
+    test("it works with empty lists", () => {
+        expect(interleave([], "x")).toEqual([]);
+    });
+    test("it works with long lists", () => {
+        expect(interleave([1, 2, 3, 1, 2, 3, 1, 2, 3], "x")).toEqual([
+            1,
+            "x",
+            2,
+            "x",
+            3,
+            "x",
+            1,
+            "x",
+            2,
+            "x",
+            3,
+            "x",
+            1,
+            "x",
+            2,
+            "x",
+            3,
+        ]);
+    });
+});

package/build/notNull.d.ts

@@ -0,0 +1 @@
+export declare const notNull: <T>(x: T) => x is NonNullable<T>;

package/build/notNull.js

@@ -0,0 +1 @@
+export const notNull = (x) => x !== null;

package/build/notNull.test.d.ts

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

package/build/notNull.test.js

@@ -0,0 +1,19 @@
+import { expect, test } from "vitest";
+import { notNull } from "./notNull.js";
+test("notNull returns false for null", () => {
+    expect(notNull(null)).toBe(false);
+});
+test("notNull returns true for non-null values", () => {
+    expect(notNull(0)).toBe(true);
+    expect(notNull("")).toBe(true);
+    expect(notNull(false)).toBe(true);
+    expect(notNull({})).toBe(true);
+    expect(notNull([])).toBe(true);
+    expect(notNull(undefined)).toBe(true);
+});
+test("notNull type guard narrows type correctly", () => {
+    const arr = [1, null, 2, null, 3];
+    const numbers = arr.filter(notNull);
+    // @ts-expect-error numbers should not contain null
+    const _test = numbers[0];
+});

package/build/toSentence.d.ts

@@ -0,0 +1 @@
+export declare const toSentence: (iter: Iterable<string>, conjunction?: string) => string | undefined;

package/build/toSentence.js

@@ -0,0 +1,13 @@
+export const toSentence = (iter, conjunction = "and") => {
+    const items = Array.from(iter);
+    switch (items.length) {
+        case 0:
+            return "";
+        case 1:
+            return items[0];
+        case 2:
+            return items.join(` ${conjunction} `);
+        default:
+            return `${items.slice(0, -1).join(", ")}, ${conjunction} ${items[items.length - 1]}`;
+    }
+};

package/build/toSentence.test.d.ts

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

package/build/toSentence.test.js

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import { toSentence } from "./toSentence.js";
+test("toSentence returns empty string for empty array", () => {
+    expect(toSentence([])).toBe("");
+});
+test("toSentence returns single item for array of one", () => {
+    expect(toSentence(["one"])).toBe("one");
+});
+test("toSentence joins two items with conjunction", () => {
+    expect(toSentence(["one", "two"])).toBe("one and two");
+});
+test("toSentence joins multiple items with commas and conjunction", () => {
+    expect(toSentence(["one", "two", "three"])).toBe("one, two, and three");
+    expect(toSentence(["one", "two", "three", "four"])).toBe("one, two, three, and four");
+});
+test("toSentence uses custom conjunction", () => {
+    expect(toSentence(["one", "two"], "or")).toBe("one or two");
+    expect(toSentence(["one", "two", "three"], "or")).toBe("one, two, or three");
+});
+test("toSentence works with Set", () => {
+    expect(toSentence(new Set(["one", "two", "three"]))).toBe("one, two, and three");
+});

package/build/types/Conform.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Not really an exact type and not exactly what we'd like -
+ * all we need is excess property checking, but that's
+ * unlikely to happen. See https://github.com/microsoft/TypeScript/issues/58031
+ * for more information.
+ */
+export type Conform<Base, T extends Base> = {
+    [K in keyof T]: T[K];
+} & {
+    [K in keyof T as K extends keyof Base ? never : K]: never;
+};

package/build/types/Conform.js

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

package/build/types/Conform.test-d.d.ts

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

package/build/types/Conform.test-d.js

@@ -0,0 +1,21 @@
+import { describe, test } from "vitest";
+describe("Conform", () => {
+    test("should allow exact matching types", () => {
+        const _ = {
+            name: "John",
+            age: 30,
+        };
+    });
+    test("should not allow extra properties", () => {
+        const _person = {
+            name: "John",
+            age: 30,
+            // @ts-expect-error - Extra property 'email' is not allowed
+            email: "john@example.com",
+        };
+    });
+    test("should not allow missing properties", () => {
+        // @ts-expect-error - Missing property 'age'
+        const _person = { name: "John" };
+    });
+});

package/build/types/MarkNonNullable.d.ts

@@ -0,0 +1,3 @@
+export type MarkNonNullable<Type, Keys extends keyof Type> = Type extends Type ? Type & {
+    [Key in Keys]-?: NonNullable<Type[Key]>;
+} : never;

package/build/types/MarkNonNullable.js

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

package/build/types/MarkNonNullable.test-d.d.ts

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

package/build/types/MarkNonNullable.test-d.js

@@ -0,0 +1,25 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("MarkNonNullable", () => {
+    test("should make specified properties non-nullable while preserving other properties", () => {
+        // name should be string only (not null)
+        expectTypeOf().toExtend();
+        // other properties should remain unchanged
+        expectTypeOf().toEqualTypeOf();
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("should handle multiple properties", () => {
+        expectTypeOf().toExtend();
+    });
+    test("should handle nested properties", () => {
+        // The address object itself should remain the same structure
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("should preserve required properties", () => {
+        // id was already required, should remain number
+        expectTypeOf().toEqualTypeOf();
+    });
+    test("should handle optional properties", () => {
+        // Optional properties should become required and non-nullable
+        expectTypeOf().toExtend();
+    });
+});

package/build/types/Simplify.d.ts

@@ -0,0 +1,3 @@
+export type Simplify<T> = {
+    [K in keyof T]: T[K] extends Date ? T[K] : T[K] extends object ? Simplify<T[K]> : T[K];
+} & unknown;

package/build/types/Simplify.js

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

package/build/types/Simplify.test-d.d.ts

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

package/build/types/Simplify.test-d.js

@@ -0,0 +1,6 @@
+import { describe, expectTypeOf, test } from "vitest";
+describe("Simplify", () => {
+    test("simplify doesn't change the structure of a type containing nested objects, strings, numbers, dates and arrays", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@casekit/toolbox",
+  "description": "",
+  "version": "0.0.0-20250322230249",
+  "author": "",
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^5.2.2",
+    "@types/node": "^22.13.11",
+    "@types/pg": "^8.11.11",
+    "@vitest/coverage-v8": "^3.0.9",
+    "dotenv": "^16.4.7",
+    "prettier": "^3.5.3",
+    "prettier-plugin-svelte": "^3.3.3",
+    "typescript": "^5.8.2",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.9",
+    "@casekit/prettier-config": "0.0.0-20250322230249",
+    "@casekit/tsconfig": "0.0.0-20250322230249"
+  },
+  "exports": {
+    ".": "./build/index.js"
+  },
+  "files": [
+    "/build"
+  ],
+  "imports": {
+    "#*": "./build/*"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "main": "index.js",
+  "peerDependencies": {
+    "pg": "^8.13.1",
+    "zod": "^3.24.2"
+  },
+  "prettier": "@casekit/prettier-config",
+  "type": "module",
+  "dependencies": {
+    "ts-essentials": "^10.0.4"
+  },
+  "scripts": {
+    "build": "rm -rf ./build && tsc --build",
+    "format:check": "prettier --check .",
+    "format": "prettier --write .",
+    "lint": "eslint src --max-warnings 0",
+    "test": "vitest --run --typecheck --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}