hanzio 1.0.0

package/dist/typedswitch/index.d.ts

@@ -0,0 +1,124 @@
+/**
+ * typedSwitch - A type-safe switch statement for discriminated unions
+ *
+ * Supports two input modes:
+ *
+ * 1. STRING INPUT - switch on a string/enum value directly:
+ *
+ *    @example
+ *    const status: 'success' | 'error' = 'success'
+ *
+ *    // All cases required (no default)
+ *    typedSwitch(status, {
+ *      success: (val) => 'handled success',
+ *      error: (val) => 'handled error',
+ *    })
+ *
+ *    // Partial cases with default handler
+ *    typedSwitch(status, {
+ *      success: (val) => 'handled success',
+ *    }, (val) => 'default handler')
+ *
+ *
+ * 2. OBJECT INPUT - switch on a discriminated union with custom key:
+ *
+ *    @example
+ *    type Event =
+ *      | { type: 'click'; x: number; y: number }
+ *      | { type: 'scroll'; offset: number }
+ *
+ *    // All cases required (no default)
+ *    typedSwitch(event, 'type', {
+ *      click: (e) => `Clicked at ${e.x}, ${e.y}`,
+ *      scroll: (e) => `Scrolled ${e.offset}px`,
+ *    })
+ *
+ *    // Partial cases with default handler
+ *    typedSwitch(event, 'type', {
+ *      click: (e) => `Clicked at ${e.x}, ${e.y}`,
+ *    }, (e) => 'unhandled event')
+ *
+ *    // Works with any discriminant key (not just 'type')
+ *    type Order = { status: 'pending' } | { status: 'completed' }
+ *    typedSwitch(order, 'status', {
+ *      pending: (o) => 'waiting...',
+ *      completed: (o) => 'done!',
+ *    })
+ *
+ *
+ * 3. WITH CONSTRAINT - use `typedSwitch<T>` to enforce return type:
+ *
+ *    @example
+ *    interface HasId { id: string }
+ *
+ *    // All handlers must return something with { id: string }
+ *    typedSwitch<HasId>(status, {
+ *      success: () => ({ id: '123', name: 'John' }), // ✓ OK
+ *      error: () => ({ id: '456' }), // ✓ OK
+ *    })
+ *
+ *    // Type error - missing 'id' property
+ *    typedSwitch<HasId>(status, {
+ *      success: () => ({ name: 'John' }), // ✗ Error!
+ *      error: () => ({ id: '456' }),
+ *    })
+ */
+/** Extract raw return type from a handler function (preserves Promise) */
+type RawHandlerReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
+/** Get union of all raw return types from a cases object's values */
+type RawCasesReturnType<Cases> = {
+    [K in keyof Cases]: Cases[K] extends undefined ? never : RawHandlerReturnType<Cases[K]>;
+}[keyof Cases];
+/** Cases for string input - all cases required */
+export type StringSwitchCases<T extends string, R> = {
+    [K in T]: (value: K) => R | Promise<R>;
+};
+/** Partial cases for string input (when default is provided) */
+export type PartialStringSwitchCases<T extends string, R> = {
+    [K in T]?: (value: K) => R | Promise<R>;
+};
+/** Cases for object input with custom key - all cases required */
+export type ObjectSwitchCases<T, K extends keyof T, R> = T[K] extends string ? {
+    [V in T[K]]: (value: Extract<T, Record<K, V>>) => R | Promise<R>;
+} : never;
+/** Partial cases for object input with custom key (when default is provided) */
+export type PartialObjectSwitchCases<T, K extends keyof T, R> = T[K] extends string ? {
+    [V in T[K]]?: (value: Extract<T, Record<K, V>>) => R | Promise<R>;
+} : never;
+export declare function typedSwitch<T extends string, Cases extends {
+    [K in T]: (value: K) => unknown;
+}>(value: T, cases: Cases): RawCasesReturnType<Cases>;
+export declare function typedSwitch<T extends string, Cases extends {
+    [K in T]?: (value: K) => unknown;
+}, DefaultCase extends (value: T) => unknown>(value: T, cases: Cases, defaultCase: DefaultCase): RawCasesReturnType<Cases> | RawHandlerReturnType<DefaultCase>;
+export declare function typedSwitch<T extends Record<string, unknown>, K extends keyof T, TKey extends T[K] & string, Cases extends {
+    [V in TKey]: (value: Extract<T, Record<K, V>>) => unknown;
+}>(value: T, key: K, cases: Cases): RawCasesReturnType<Cases>;
+export declare function typedSwitch<T extends Record<string, unknown>, K extends keyof T, TKey extends T[K] & string, Cases extends {
+    [V in TKey]?: (value: Extract<T, Record<K, V>>) => unknown;
+}, DefaultCase extends (value: T) => unknown>(value: T, key: K, cases: Cases, defaultCase: DefaultCase): RawCasesReturnType<Cases> | RawHandlerReturnType<DefaultCase>;
+export declare function typedSwitch<Constraint, T extends string = string>(value: T, cases: {
+    [K in T]: (value: K) => Constraint;
+}): Constraint;
+export declare function typedSwitch<Constraint, T extends string = string>(value: T, cases: {
+    [K in T]: (value: K) => Constraint | Promise<Constraint>;
+}): Constraint | Promise<Constraint>;
+export declare function typedSwitch<Constraint, T extends string = string>(value: T, cases: {
+    [K in T]?: (value: K) => Constraint;
+}, defaultCase: (value: T) => Constraint): Constraint;
+export declare function typedSwitch<Constraint, T extends string = string>(value: T, cases: {
+    [K in T]?: (value: K) => Constraint | Promise<Constraint>;
+}, defaultCase: (value: T) => Constraint | Promise<Constraint>): Constraint | Promise<Constraint>;
+export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: {
+    [V in T[K] & string]: (value: Extract<T, Record<K, V>>) => Constraint;
+}): Constraint;
+export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: {
+    [V in T[K] & string]: (value: Extract<T, Record<K, V>>) => Constraint | Promise<Constraint>;
+}): Constraint | Promise<Constraint>;
+export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: {
+    [V in T[K] & string]?: (value: Extract<T, Record<K, V>>) => Constraint;
+}, defaultCase: (value: T) => Constraint): Constraint;
+export declare function typedSwitch<Constraint, T extends Record<string, unknown> = Record<string, unknown>, K extends keyof T = keyof T>(value: T, key: K, cases: {
+    [V in T[K] & string]?: (value: Extract<T, Record<K, V>>) => Constraint | Promise<Constraint>;
+}, defaultCase: (value: T) => Constraint | Promise<Constraint>): Constraint | Promise<Constraint>;
+export {};

package/dist/url/index.d.ts

@@ -0,0 +1 @@
+export declare function getDomainFaviconUrl(domain: string, size?: number): string;

package/dist/zod/index.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export { jsonToZodSchemaMapper } from './jsonToZodSchemaMapper';
+export { toGteLteFilter, type ZodMinMaxFilter, zodMinMaxFilter } from './zodMinMaxFilter';
+export { zodToExample, zodToTypeString } from './zodToTypeString';
+export type GenericId<TypeName extends string> = string & z.$brand<TypeName>;
+export declare function createZId<TypeName extends string>(typeName: TypeName): PropertyKey extends TypeName ? z.ZodString : z.core.$ZodBranded<z.ZodString, TypeName, "out">;
+export declare function zSingleOrArray<T extends z.ZodType>(schema: T): z.ZodUnion<readonly [z.ZodArray<T>, T]>;
+export declare function normalizeSingleOrArray<T>(value: T | readonly T[] | null | undefined): T[];

package/dist/zod/index.js

@@ -0,0 +1,210 @@
+// src/zod/index.ts
+import { z as z3 } from "zod";
+
+// src/zod/jsonToZodSchemaMapper.ts
+import { z } from "zod";
+function jsonToZodSchemaMapper(jsonObject, zodSchema, config) {
+  const result = {};
+  const shape = zodSchema instanceof z.ZodObject ? zodSchema.shape : {};
+  for (const key of Object.keys(shape)) {
+    const fieldConfig = config[key];
+    let value = jsonObject[key];
+    if (fieldConfig) {
+      value = fieldConfig(jsonObject);
+    }
+    if (shape[key] instanceof z.ZodObject && value && typeof value === "object") {
+      result[key] = jsonToZodSchemaMapper(value, shape[key], config[key] || {});
+    } else {
+      result[key] = value;
+    }
+  }
+  return zodSchema.parse(result);
+}
+// src/zod/zodMinMaxFilter.ts
+import { z as z2 } from "zod";
+var zodMinMaxFilter = z2.object({
+  min: z2.number().optional(),
+  max: z2.number().optional()
+});
+function toGteLteFilter(filter) {
+  if (!filter)
+    return;
+  const hasMin = filter.min !== undefined;
+  const hasMax = filter.max !== undefined;
+  if (!hasMin && !hasMax)
+    return;
+  return {
+    ...hasMin && { gte: filter.min },
+    ...hasMax && { lte: filter.max }
+  };
+}
+// src/zod/zodToTypeString.ts
+function getDefProp(def, prop) {
+  return def?.[prop];
+}
+function zodToTypeString(schema, indent = 0) {
+  const pad = "  ".repeat(indent);
+  const innerPad = "  ".repeat(indent + 1);
+  const def = schema._zod?.def ?? schema._def;
+  if (!def)
+    return "unknown";
+  const schemaType = getDefProp(def, "type") ?? getDefProp(def, "typeName");
+  switch (schemaType) {
+    case "object": {
+      const shape = getDefProp(def, "shape");
+      if (!shape || Object.keys(shape).length === 0)
+        return "{}";
+      const fields = Object.entries(shape).map(([key, value]) => {
+        const valueType = getDefProp(value._zod?.def ?? value._def, "type");
+        const isOptional = valueType === "optional";
+        const innerSchema = isOptional ? getDefProp(value._zod?.def ?? value._def, "innerType") ?? value : value;
+        const typeStr = zodToTypeString(innerSchema, indent + 1);
+        return `${innerPad}${key}${isOptional ? "?" : ""}: ${typeStr}`;
+      });
+      return `{
+${fields.join(`
+`)}
+${pad}}`;
+    }
+    case "array": {
+      const itemType = getDefProp(def, "element") ?? getDefProp(def, "type");
+      return itemType ? `${zodToTypeString(itemType, indent)}[]` : "unknown[]";
+    }
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "Date";
+    case "null":
+      return "null";
+    case "undefined":
+      return "undefined";
+    case "any":
+      return "any";
+    case "unknown":
+      return "unknown";
+    case "record": {
+      const valueType = getDefProp(def, "valueType");
+      return valueType ? `Record<string, ${zodToTypeString(valueType, indent)}>` : "Record<string, unknown>";
+    }
+    case "enum": {
+      const values = getDefProp(def, "values");
+      return values ? values.map((v) => `"${v}"`).join(" | ") : "string";
+    }
+    case "literal": {
+      const value = getDefProp(def, "value");
+      return typeof value === "string" ? `"${value}"` : String(value);
+    }
+    case "union": {
+      const options = getDefProp(def, "options");
+      return options ? options.map((o) => zodToTypeString(o, indent)).join(" | ") : "unknown";
+    }
+    case "optional": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? `${zodToTypeString(inner, indent)} | undefined` : "unknown";
+    }
+    case "nullable": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? `${zodToTypeString(inner, indent)} | null` : "unknown";
+    }
+    case "default": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? zodToTypeString(inner, indent) : "unknown";
+    }
+    case "ZodObject":
+    case "ZodArray":
+    case "ZodString":
+    case "ZodNumber":
+    case "ZodBoolean":
+    case "ZodDate":
+    case "ZodNull":
+    case "ZodUndefined":
+    case "ZodAny":
+    case "ZodUnknown":
+    case "ZodRecord":
+    case "ZodEnum":
+    case "ZodLiteral":
+    case "ZodUnion":
+    case "ZodOptional":
+    case "ZodNullable":
+    case "ZodDefault":
+      return zodToTypeString(schema, indent);
+    default:
+      return "unknown";
+  }
+}
+function zodToExample(schema) {
+  const def = schema._zod?.def ?? schema._def;
+  if (!def)
+    return null;
+  const schemaType = getDefProp(def, "type") ?? getDefProp(def, "typeName");
+  switch (schemaType) {
+    case "object": {
+      const shape = getDefProp(def, "shape");
+      if (!shape)
+        return {};
+      const result = {};
+      for (const [key, value] of Object.entries(shape)) {
+        const valueType = getDefProp(value._zod?.def ?? value._def, "type");
+        const isOptional = valueType === "optional";
+        if (!isOptional) {
+          result[key] = zodToExample(value);
+        }
+      }
+      return result;
+    }
+    case "array": {
+      const itemType = getDefProp(def, "element") ?? getDefProp(def, "type");
+      return itemType ? [zodToExample(itemType)] : [];
+    }
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "enum": {
+      const values = getDefProp(def, "values");
+      return values?.[0] ?? "";
+    }
+    case "literal":
+      return getDefProp(def, "value");
+    case "optional":
+    case "default": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? zodToExample(inner) : null;
+    }
+    case "record":
+      return {};
+    default:
+      return null;
+  }
+}
+
+// src/zod/index.ts
+function createZId(typeName) {
+  return z3.string().min(1, `${typeName} ID is required`).brand();
+}
+function zSingleOrArray(schema) {
+  return z3.union([z3.array(schema), schema]);
+}
+function normalizeSingleOrArray(value) {
+  if (value == null)
+    return [];
+  if (Array.isArray(value))
+    return [...value];
+  return [value];
+}
+export {
+  zodToTypeString,
+  zodToExample,
+  zodMinMaxFilter,
+  zSingleOrArray,
+  toGteLteFilter,
+  normalizeSingleOrArray,
+  jsonToZodSchemaMapper,
+  createZId
+};

package/dist/zod/jsonToZodSchemaMapper.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+type PropertyConfig<T, U> = {
+    [K in keyof T]?: (jsonObject: U) => T[K];
+};
+export declare function jsonToZodSchemaMapper<T extends z.ZodType, U extends Record<string, any>>(jsonObject: U, zodSchema: T, config: PropertyConfig<z.infer<T>, U>): z.infer<T>;
+export {};

package/dist/zod/zodMinMaxFilter.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const zodMinMaxFilter: z.ZodObject<{
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ZodMinMaxFilter = z.infer<typeof zodMinMaxFilter>;
+/**
+ * Maps a min/max filter to a generic `gte`/`lte` range object (e.g. ORM-friendly).
+ * Returns `undefined` if both bounds are undefined.
+ */
+export declare function toGteLteFilter(filter: ZodMinMaxFilter | undefined): {
+    gte?: number;
+    lte?: number;
+} | undefined;

package/dist/zod/zodToTypeString.d.ts

@@ -0,0 +1,9 @@
+import type { z } from 'zod';
+/**
+ * Convert a Zod schema to a human-readable TypeScript-like interface string
+ */
+export declare function zodToTypeString(schema: z.ZodType, indent?: number): string;
+/**
+ * Generate example JSON from a Zod schema
+ */
+export declare function zodToExample(schema: z.ZodType): unknown;

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "hanzio",
+  "version": "1.0.0",
+  "description": "A set of utility functions for TypeScript",
+  "type": "module",
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HansKristoffer/hanzio.git"
+  },
+  "author": "Kristoffer Hansen",
+  "keywords": [
+    "typescript",
+    "utility",
+    "functions",
+    "type-safe",
+    "exhaustive",
+    "union-types"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "files": [
+    "src/**/*.ts",
+    "dist",
+    "!src/**/*.test.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./zod": {
+      "types": "./dist/zod/index.d.ts",
+      "bun": "./src/zod/index.ts",
+      "import": "./dist/zod/index.js",
+      "default": "./dist/zod/index.js"
+    },
+    "./api-wrapper": {
+      "types": "./dist/api-wrapper/index.d.ts",
+      "bun": "./src/api-wrapper/index.ts",
+      "import": "./dist/api-wrapper/index.js",
+      "default": "./dist/api-wrapper/index.js"
+    },
+    "./jwt": {
+      "types": "./dist/jwt/index.d.ts",
+      "bun": "./src/jwt/index.ts",
+      "import": "./dist/jwt/index.js",
+      "default": "./dist/jwt/index.js"
+    },
+    "./gzip": {
+      "types": "./dist/gzip/index.d.ts",
+      "bun": "./src/gzip/index.ts",
+      "import": "./dist/gzip/index.js",
+      "default": "./dist/gzip/index.js"
+    },
+    "./sitemap": {
+      "types": "./dist/sitemap/index.d.ts",
+      "bun": "./src/sitemap/index.ts",
+      "import": "./dist/sitemap/index.js",
+      "default": "./dist/sitemap/index.js"
+    },
+    "./p-queue": {
+      "types": "./dist/p-queue/index.d.ts",
+      "bun": "./src/p-queue/index.ts",
+      "import": "./dist/p-queue/index.js",
+      "default": "./dist/p-queue/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun run build:js && bun run build:types",
+    "build:js": "bun build ./src/index.ts ./src/zod/index.ts ./src/api-wrapper/index.ts ./src/jwt/index.ts ./src/gzip/index.ts ./src/sitemap/index.ts ./src/p-queue/index.ts --outdir ./dist --target node --packages external",
+    "build:types": "tsgo -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "publish:patch": "npm version patch && npm publish",
+    "publish:minor": "npm version minor && npm publish",
+    "publish:major": "npm version major && npm publish",
+    "test": "bun test",
+    "lint": "bun run typecheck && bun biome check",
+    "lint:write": "bun run typecheck && bun biome check --write",
+    "typecheck": "tsgo --noEmit",
+    "prepare": "husky"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.6",
+    "@types/bun": "latest",
+    "@types/pako": "^2.0.4",
+    "@typescript/native-preview": "^7.0.0-dev.20260306.1",
+    "husky": "^9.1.7",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "jose": "^6.2.3",
+    "pako": "^2.1.0",
+    "zod": "^4.3.6"
+  }
+}