hanzio 1.2.0 → 2.1.0

package/dist/src/storage/index.js

@@ -0,0 +1,119 @@
+// src/storage/index.ts
+function createMemoryStorage() {
+  const map = new Map;
+  return {
+    getItem: (key) => map.get(key) ?? null,
+    setItem: (key, value) => {
+      map.set(key, String(value));
+    },
+    removeItem: (key) => {
+      map.delete(key);
+    }
+  };
+}
+var sharedMemoryStorage;
+function defaultStorage() {
+  try {
+    const storage = globalThis.localStorage;
+    if (storage)
+      return storage;
+  } catch {}
+  sharedMemoryStorage ??= createMemoryStorage();
+  return sharedMemoryStorage;
+}
+function createCodec(options) {
+  const {
+    fallback,
+    parse = (raw) => raw,
+    serialize = JSON.stringify,
+    deserialize = JSON.parse
+  } = options;
+  return {
+    serialize,
+    decode(raw) {
+      if (raw === null)
+        return fallback;
+      try {
+        return parse(deserialize(raw));
+      } catch {
+        return fallback;
+      }
+    }
+  };
+}
+function createStorageItem(options) {
+  const { key, fallback, storage = defaultStorage() } = options;
+  const { serialize, decode } = createCodec(options);
+  let mirror;
+  const write = (value, action) => {
+    try {
+      action();
+      mirror = undefined;
+    } catch {
+      mirror = { value };
+    }
+  };
+  const get = () => {
+    if (mirror)
+      return mirror.value;
+    try {
+      return decode(storage.getItem(key));
+    } catch {
+      return fallback;
+    }
+  };
+  return {
+    key,
+    get,
+    set: (value) => write(value, () => storage.setItem(key, serialize(value))),
+    remove: () => write(fallback, () => storage.removeItem(key)),
+    subscribe(listener) {
+      const target = globalThis;
+      if (!target.addEventListener || !target.removeEventListener) {
+        return () => {};
+      }
+      const onStorage = (event) => {
+        if (event.storageArea !== storage)
+          return;
+        if (event.key !== key && event.key !== null)
+          return;
+        mirror = undefined;
+        listener(get());
+      };
+      target.addEventListener("storage", onStorage);
+      return () => target.removeEventListener?.("storage", onStorage);
+    }
+  };
+}
+function createAsyncStorageItem(options) {
+  const { key, fallback, storage } = options;
+  const { serialize, decode } = createCodec(options);
+  let mirror;
+  const write = async (value, action) => {
+    try {
+      await action();
+      mirror = undefined;
+    } catch {
+      mirror = { value };
+    }
+  };
+  return {
+    key,
+    async get() {
+      if (mirror)
+        return mirror.value;
+      try {
+        return decode(await storage.getItem(key));
+      } catch {
+        return fallback;
+      }
+    },
+    set: (value) => write(value, () => storage.setItem(key, serialize(value))),
+    remove: () => write(fallback, () => storage.removeItem(key))
+  };
+}
+export {
+  createAsyncStorageItem,
+  createMemoryStorage,
+  createStorageItem
+};

package/dist/src/zod/index.js

@@ -1,32 +1,299 @@
+import {
+  toArray2
+} from "../../index-hy7kbb99.js";
+import {
+  ok2,
+  err2
+} from "../../index-0zvtcbzy.js";
+import {
+  isRecord2
+} from "../../index-8r2vdzjg.js";
+
 // src/zod/index.ts
 import { z as z3 } from "zod";
 
+// src/zod/zodToTypeString.ts
+var visiting = new Set;
+function walk(schema, onCycle, fn) {
+  if (visiting.has(schema))
+    return onCycle;
+  visiting.add(schema);
+  try {
+    return fn(defOf(schema));
+  } finally {
+    visiting.delete(schema);
+  }
+}
+function defOf(schema) {
+  return schema._zod.def;
+}
+function pipeTarget(def) {
+  return defOf(def.out).type === "transform" ? def.in : def.out;
+}
+function literal(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  return typeof value === "bigint" ? `${value}n` : String(value);
+}
+function wrap(type) {
+  return /[|&]/.test(type) ? `(${type})` : type;
+}
+function zodToTypeString(schema, indent = 0) {
+  return walk(schema, "unknown", (def) => {
+    const pad = "  ".repeat(indent);
+    const innerPad = "  ".repeat(indent + 1);
+    const render = (inner) => zodToTypeString(inner, indent);
+    switch (def.type) {
+      case "object": {
+        const entries = Object.entries(def.shape);
+        if (entries.length === 0)
+          return "{}";
+        const fields = entries.map(([key, value]) => {
+          const valueDef = defOf(value);
+          const isOptional = valueDef.type === "optional";
+          const typeStr = zodToTypeString(isOptional ? valueDef.innerType : value, indent + 1);
+          return `${innerPad}${key}${isOptional ? "?" : ""}: ${typeStr}`;
+        });
+        return `{
+${fields.join(`
+`)}
+${pad}}`;
+      }
+      case "array":
+        return `${wrap(render(def.element))}[]`;
+      case "tuple": {
+        const items = def.items.map(render);
+        if (def.rest)
+          items.push(`...${wrap(render(def.rest))}[]`);
+        return `[${items.join(", ")}]`;
+      }
+      case "string":
+      case "number":
+      case "bigint":
+      case "boolean":
+      case "symbol":
+      case "null":
+      case "undefined":
+      case "void":
+      case "never":
+      case "any":
+      case "unknown":
+        return def.type;
+      case "date":
+        return "Date";
+      case "record":
+        return `Record<${render(def.keyType)}, ${render(def.valueType)}>`;
+      case "map":
+        return `Map<${render(def.keyType)}, ${render(def.valueType)}>`;
+      case "set":
+        return `Set<${render(def.valueType)}>`;
+      case "promise":
+        return `Promise<${render(def.innerType)}>`;
+      case "enum":
+        return Object.values(def.entries).map(literal).join(" | ");
+      case "literal":
+        return def.values.map(literal).join(" | ");
+      case "union":
+        return def.options.map(render).join(" | ");
+      case "intersection":
+        return `${wrap(render(def.left))} & ${wrap(render(def.right))}`;
+      case "optional":
+        return `${render(def.innerType)} | undefined`;
+      case "nullable":
+        return `${render(def.innerType)} | null`;
+      case "nonoptional": {
+        const innerDef = defOf(def.innerType);
+        return render(innerDef.type === "optional" ? innerDef.innerType : def.innerType);
+      }
+      case "default":
+      case "prefault":
+      case "catch":
+      case "readonly":
+        return render(def.innerType);
+      case "lazy":
+        return render(def.getter());
+      case "pipe":
+        return render(pipeTarget(def));
+      default:
+        return "unknown";
+    }
+  });
+}
+function zodToExample(schema) {
+  return walk(schema, null, (def) => {
+    switch (def.type) {
+      case "object": {
+        const result = {};
+        for (const [key, value] of Object.entries(def.shape)) {
+          if (defOf(value).type !== "optional") {
+            result[key] = zodToExample(value);
+          }
+        }
+        return result;
+      }
+      case "array":
+        return [zodToExample(def.element)];
+      case "set":
+        return [zodToExample(def.valueType)];
+      case "tuple":
+        return def.items.map(zodToExample);
+      case "string":
+        return "";
+      case "number":
+      case "bigint":
+        return 0;
+      case "boolean":
+        return false;
+      case "date":
+        return new Date(0).toISOString();
+      case "enum":
+        return Object.values(def.entries)[0];
+      case "literal":
+        return def.values[0];
+      case "union":
+        return zodToExample(def.options[0]);
+      case "intersection": {
+        const left = zodToExample(def.left);
+        const right = zodToExample(def.right);
+        return isRecord2(left) && isRecord2(right) ? { ...left, ...right } : left;
+      }
+      case "optional":
+      case "nullable":
+      case "nonoptional":
+      case "default":
+      case "prefault":
+      case "catch":
+      case "readonly":
+      case "promise":
+        return zodToExample(def.innerType);
+      case "lazy":
+        return zodToExample(def.getter());
+      case "pipe":
+        return zodToExample(pipeTarget(def));
+      case "record":
+      case "map":
+        return {};
+      default:
+        return null;
+    }
+  });
+}
+
+// src/zod/introspect.ts
+function pipeInput(def) {
+  return defOf(def.in).type === "transform" ? def.out : def.in;
+}
+function unwrapOnce(def) {
+  switch (def.type) {
+    case "optional":
+    case "nullable":
+    case "default":
+    case "prefault":
+    case "nonoptional":
+    case "catch":
+    case "readonly":
+      return def.innerType;
+    case "lazy":
+      return def.getter();
+    case "pipe":
+      return pipeInput(def);
+    default:
+      return;
+  }
+}
+function unwrapSchema(schema) {
+  const inner = unwrapOnce(defOf(schema));
+  return inner ? unwrapSchema(inner) : schema;
+}
+function getEnumValues(schema) {
+  const def = defOf(unwrapSchema(schema));
+  return def.type === "enum" ? Object.values(def.entries).map(String) : undefined;
+}
+function getObjectShape(schema) {
+  const def = defOf(unwrapSchema(schema));
+  return def.type === "object" ? def.shape : undefined;
+}
+function zodDefaults(schema) {
+  return defaultFor(schema);
+}
+function defaultFor(schema) {
+  return walk(schema, undefined, (def) => {
+    switch (def.type) {
+      case "default":
+      case "prefault":
+        return def.defaultValue;
+      case "optional":
+        return;
+      case "nullable":
+        return null;
+      case "object": {
+        const result = {};
+        for (const [key, child] of Object.entries(def.shape)) {
+          result[key] = defaultFor(child);
+        }
+        return result;
+      }
+      case "array":
+        return [];
+      case "string":
+        return "";
+      case "number":
+        return 0;
+      case "bigint":
+        return 0n;
+      case "boolean":
+        return false;
+      case "enum":
+        return Object.values(def.entries)[0];
+      case "literal":
+        return def.values[0];
+      case "union":
+        return def.options[0] && defaultFor(def.options[0]);
+      default: {
+        const inner = unwrapOnce(def);
+        return inner && defaultFor(inner);
+      }
+    }
+  });
+}
 // src/zod/jsonToZodSchemaMapper.ts
 import { z } from "zod";
 function jsonToZodSchemaMapper(jsonObject, zodSchema, config) {
+  return zodSchema.parse(mapObject(jsonObject, zodSchema, config));
+}
+function mapObject(jsonObject, schema, config) {
+  const shape = schema instanceof z.ZodObject ? schema.shape : {};
   const result = {};
-  const shape = zodSchema instanceof z.ZodObject ? zodSchema.shape : {};
-  for (const key of Object.keys(shape)) {
+  for (const [key, fieldSchema] of Object.entries(shape)) {
     const fieldConfig = config[key];
-    let value = jsonObject[key];
-    if (fieldConfig) {
-      value = fieldConfig(jsonObject);
+    if (typeof fieldConfig === "function") {
+      result[key] = fieldConfig(jsonObject);
+      continue;
     }
-    if (shape[key] instanceof z.ZodObject && value && typeof value === "object") {
-      result[key] = jsonToZodSchemaMapper(value, shape[key], config[key] || {});
+    const nested = fieldConfig ?? {};
+    const value = jsonObject[key];
+    const inner = unwrap(fieldSchema);
+    const element = inner instanceof z.ZodArray && unwrap(inner.element);
+    if (inner instanceof z.ZodObject && isRecord2(value)) {
+      result[key] = mapObject(value, inner, nested);
+    } else if (element instanceof z.ZodObject && Array.isArray(value)) {
+      result[key] = value.map((item) => isRecord2(item) ? mapObject(item, element, nested) : item);
     } else {
       result[key] = value;
     }
   }
-  return zodSchema.parse(result);
+  return result;
+}
+function unwrap(schema) {
+  return schema instanceof z.ZodOptional || schema instanceof z.ZodNullable ? unwrap(schema.unwrap()) : schema;
 }
 // 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) {
+function createMinMaxFilter(schema) {
+  return z2.object({ min: schema.optional(), max: schema.optional() });
+}
+var zodMinMaxFilter = createMinMaxFilter(z2.number());
+function toRange(filter, lower, upper) {
   if (!filter)
     return;
   const hasMin = filter.min !== undefined;
@@ -34,176 +301,82 @@ function toGteLteFilter(filter) {
   if (!hasMin && !hasMax)
     return;
   return {
-    ...hasMin && { gte: filter.min },
-    ...hasMax && { lte: filter.max }
+    ...hasMin && { [lower]: filter.min },
+    ...hasMax && { [upper]: filter.max }
   };
 }
-// src/zod/zodToTypeString.ts
-function getDefProp(def, prop) {
-  return def?.[prop];
+function toGteLteFilter(filter) {
+  return toRange(filter, "gte", "lte");
 }
-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;
-  }
+function toGtLtFilter(filter) {
+  return toRange(filter, "gt", "lt");
 }
 
 // src/zod/index.ts
-function createZId(typeName) {
-  return z3.string().min(1, `${typeName} ID is required`).brand();
+function createZId(typeName, { prefix = "" } = {}) {
+  return z3.string().min(1, `${typeName} ID is required`).startsWith(prefix, `${typeName} ID must start with "${prefix}"`).brand();
+}
+function asId(value) {
+  return value;
+}
+function parseId(typeName, value) {
+  return createZId(typeName).parse(value);
+}
+function safeParseId(typeName, value) {
+  return toResult(createZId(typeName).safeParse(value));
+}
+function createIdHelpers() {
+  return {
+    zId: (typeName) => createZId(typeName),
+    asId,
+    parseId,
+    safeParseId
+  };
+}
+var zJsonValue = z3.lazy(() => z3.union([
+  z3.string(),
+  z3.number(),
+  z3.boolean(),
+  z3.null(),
+  z3.array(zJsonValue),
+  zJsonObject
+]));
+var zJsonObject = z3.record(z3.string(), zJsonValue);
+function parseJson(text, schema) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    return { ok: false, data: null, error };
+  }
+  return toResult(schema.safeParse(value));
+}
+function toResult(result) {
+  return result.success ? ok2(result.data) : err2(result.error);
 }
 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];
-}
+var normalizeSingleOrArray = toArray2;
 export {
+  asId,
+  createIdHelpers,
+  createMinMaxFilter,
   createZId,
+  getEnumValues,
+  getObjectShape,
   jsonToZodSchemaMapper,
   normalizeSingleOrArray,
+  parseId,
+  parseJson,
+  safeParseId,
+  toGtLtFilter,
   toGteLteFilter,
+  unwrapSchema,
+  zJsonObject,
+  zJsonValue,
   zSingleOrArray,
+  zodDefaults,
   zodMinMaxFilter,
   zodToExample,
   zodToTypeString

package/dist/state/index.d.ts

@@ -46,6 +46,10 @@ export interface StateMachineConfig<TState extends string, TAction extends strin
     stateTransitions: Record<TState, readonly TState[]>;
     validators?: Partial<Record<TState, ValidatorFn<TState, TContext, TAction>>>;
     globalValidator?: ValidatorFn<TState, TContext, TAction>;
+    actionValidators?: Partial<Record<TAction, ValidatorFn<TState, TContext, TAction>>>;
+    initialState?: TState;
+    onTransition?: (context: TContext, from: TState, to: TState, action: TAction) => void | Promise<void>;
+    applyTransition?: boolean;
     actions?: {
         [K in TAction]?: ActionHandlerFn<TContext, TActionDataMap[K], TActionResultMap[K]>;
     };
@@ -74,6 +78,12 @@ export declare class SimpleStateMachine<TState extends string, TAction extends s
      * @returns Map of target states to validation results (true if any action to that state validates)
      */
     getPossibleTransitions(): Promise<Partial<Record<TState, ValidationResult>>>;
+    /**
+     * Checks whether an action can be executed from the current state
+     *
+     * @returns true, or the reason the action is not allowed
+     */
+    canExecute(action: TAction): Promise<ValidationResult>;
     /**
      * Executes an action with additional data
      *
@@ -99,3 +109,14 @@ export declare class SimpleStateMachine<TState extends string, TAction extends s
      */
     getInitialState(): TState | undefined;
 }
+/**
+ * Defines a state machine config once and binds it to items on demand
+ *
+ * @example
+ * const orderMachine = createStateMachine<Status, Action, Order>(config)
+ * const machine = orderMachine.for(order, 'status')
+ */
+export declare function createStateMachine<TState extends string, TAction extends string, TContext, TActionDataMap extends ActionDataMap<TAction> = ActionDataMap<TAction>, TActionResultMap extends ActionResultMap<TAction> = ActionResultMap<TAction>>(config: StateMachineConfig<TState, TAction, TContext, TActionDataMap, TActionResultMap>): {
+    config: StateMachineConfig<TState, TAction, TContext, TActionDataMap, TActionResultMap>;
+    for: (item: TContext, stateKey: StateKey<TContext, TState>) => SimpleStateMachine<TState, TAction, TContext, TActionDataMap, TActionResultMap>;
+};