@awsless/validate 0.0.3 → 0.0.5

package/dist/index.cjs

@@ -15,215 +15,141 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  Struct: () => import_superstruct7.Struct,
-  StructError: () => import_superstruct7.StructError,
-  any: () => import_superstruct7.any,
-  array: () => import_superstruct7.array,
-  assert: () => import_superstruct7.assert,
-  assign: () => import_superstruct7.assign,
   bigfloat: () => bigfloat,
-  bigint: () => import_superstruct7.bigint,
-  boolean: () => import_superstruct7.boolean,
-  coerce: () => import_superstruct7.coerce,
-  create: () => import_superstruct7.create,
   date: () => date,
-  defaulted: () => import_superstruct7.defaulted,
-  define: () => import_superstruct7.define,
-  deprecated: () => import_superstruct7.deprecated,
-  dynamic: () => import_superstruct7.dynamic,
-  empty: () => import_superstruct7.empty,
-  enums: () => import_superstruct7.enums,
-  func: () => import_superstruct7.func,
-  instance: () => import_superstruct7.instance,
-  integer: () => import_superstruct7.integer,
-  intersection: () => import_superstruct7.intersection,
-  is: () => import_superstruct7.is,
   json: () => json,
-  lazy: () => import_superstruct7.lazy,
-  literal: () => import_superstruct7.literal,
-  lowercase: () => lowercase,
-  map: () => import_superstruct7.map,
-  mask: () => import_superstruct7.mask,
-  max: () => import_superstruct7.max,
-  min: () => import_superstruct7.min,
-  never: () => import_superstruct7.never,
-  nonempty: () => import_superstruct7.nonempty,
-  nullable: () => import_superstruct7.nullable,
-  number: () => import_superstruct7.number,
-  object: () => import_superstruct7.object,
-  omit: () => import_superstruct7.omit,
-  optional: () => import_superstruct7.optional,
-  partial: () => import_superstruct7.partial,
-  pattern: () => import_superstruct7.pattern,
-  pick: () => import_superstruct7.pick,
   positive: () => positive,
   precision: () => precision,
-  record: () => import_superstruct7.record,
-  refine: () => import_superstruct7.refine,
-  regexp: () => import_superstruct7.regexp,
-  set: () => import_superstruct7.set,
-  size: () => import_superstruct7.size,
-  string: () => import_superstruct7.string,
-  struct: () => import_superstruct7.struct,
-  trimmed: () => import_superstruct7.trimmed,
-  tuple: () => import_superstruct7.tuple,
-  type: () => import_superstruct7.type,
-  union: () => import_superstruct7.union,
   unique: () => unique,
-  unknown: () => import_superstruct7.unknown,
-  uppercase: () => uppercase,
   uuid: () => uuid
 });
 module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("valibot"), module.exports);
 
-// src/types/bigfloat.ts
-var import_superstruct = require("superstruct");
-var import_big_float = require("@awsless/big-float");
-var bigfloat = () => {
-  const base = (0, import_superstruct.define)("bigfloat", (value) => {
-    return value instanceof import_big_float.BigFloat || "Invalid number";
-  });
-  return (0, import_superstruct.coerce)(base, (0, import_superstruct.union)([(0, import_superstruct.string)(), (0, import_superstruct.number)()]), (value) => {
-    if (typeof value === "string" && value !== "" || typeof value === "number") {
-      if (!isNaN(Number(value))) {
-        return new import_big_float.BigFloat(value);
+// src/schema/json.ts
+var import_valibot = require("valibot");
+var json = (schema) => {
+  return (0, import_valibot.transform)(
+    (0, import_valibot.string)(),
+    (value) => {
+      try {
+        return JSON.parse(value);
+      } catch (error) {
+        return null;
       }
-    }
-    return null;
-  });
-};
-var positive = (struct2) => {
-  const expected = `Expected a positive ${struct2.type}`;
-  const ZERO = new import_big_float.BigFloat(0);
-  return (0, import_superstruct.refine)(struct2, "positive", (value) => {
-    return (0, import_big_float.gt)(value, ZERO) || `${expected} but received '${value}'`;
-  });
-};
-var precision = (struct2, decimals) => {
-  const expected = `Expected a ${struct2.type}`;
-  return (0, import_superstruct.refine)(struct2, "precision", (value) => {
-    const big = new import_big_float.BigFloat(value);
-    return -big.exponent <= decimals || `${expected} with ${decimals} decimals`;
-  });
+    },
+    schema
+  );
 };
 
-// src/types/date.ts
-var import_superstruct2 = require("superstruct");
-var date = () => {
-  return (0, import_superstruct2.coerce)((0, import_superstruct2.date)(), (0, import_superstruct2.string)(), (value) => {
-    return new Date(value);
-  });
-};
+// src/schema/bigfloat.ts
+var import_big_float = require("@awsless/big-float");
+var import_valibot2 = require("valibot");
+var make = (value) => new import_big_float.BigFloat(value);
+function bigfloat(arg1, arg2) {
+  const [msg, pipe] = (0, import_valibot2.getDefaultArgs)(arg1, arg2);
+  const error = msg ?? "Invalid bigfloat";
+  return (0, import_valibot2.union)(
+    [
+      (0, import_valibot2.instance)(import_big_float.BigFloat, pipe),
+      (0, import_valibot2.transform)(
+        (0, import_valibot2.string)([
+          (input) => {
+            if (input === "" || isNaN(Number(input))) {
+              return (0, import_valibot2.getPipeIssues)("bigfloat", error, input);
+            }
+            return (0, import_valibot2.getOutput)(input);
+          }
+        ]),
+        make,
+        pipe
+      ),
+      (0, import_valibot2.transform)((0, import_valibot2.number)(), make, pipe),
+      (0, import_valibot2.transform)(
+        (0, import_valibot2.object)({
+          exponent: (0, import_valibot2.number)(),
+          coefficient: (0, import_valibot2.bigint)()
+        }),
+        make,
+        pipe
+      )
+    ],
+    error
+  );
+}
+
+// src/schema/date.ts
+var import_valibot3 = require("valibot");
+function date(arg1, arg2) {
+  const [error, pipe] = (0, import_valibot3.getDefaultArgs)(arg1, arg2);
+  return (0, import_valibot3.union)(
+    [
+      (0, import_valibot3.date)(pipe),
+      (0, import_valibot3.transform)(
+        (0, import_valibot3.string)(),
+        (input) => {
+          return new Date(input);
+        },
+        (0, import_valibot3.date)(pipe)
+      )
+    ],
+    error ?? "Invalid date"
+  );
+}
 
-// src/types/uuid.ts
-var import_superstruct3 = require("superstruct");
+// src/schema/uuid.ts
+var import_valibot4 = require("valibot");
 var uuid = () => {
-  return (0, import_superstruct3.define)("uuid", (value) => {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(String(value));
-  });
+  return (0, import_valibot4.transform)((0, import_valibot4.string)([(0, import_valibot4.uuid)()]), (v) => v);
 };
 
-// src/types/json.ts
-var import_superstruct4 = require("superstruct");
-var json = (struct2) => {
-  return (0, import_superstruct4.coerce)(struct2, (0, import_superstruct4.string)(), (value) => {
-    try {
-      return JSON.parse(value);
-    } catch (error) {
-      return value;
-    }
-  });
-};
+// src/validation/positive.ts
+var import_big_float2 = require("@awsless/big-float");
+var import_valibot5 = require("valibot");
+function positive(error) {
+  return (input) => {
+    return (0, import_big_float2.gt)(input, import_big_float2.ZERO) ? (0, import_valibot5.getOutput)(input) : (0, import_valibot5.getPipeIssues)("positive", error ?? "Invalid positive number", input);
+  };
+}
 
-// src/types/string.ts
-var import_superstruct5 = require("superstruct");
-var lowercase = (struct2) => {
-  return (0, import_superstruct5.coerce)(struct2, (0, import_superstruct5.string)(), (value) => value.toLowerCase());
-};
-var uppercase = (struct2) => {
-  return (0, import_superstruct5.coerce)(struct2, (0, import_superstruct5.string)(), (value) => value.toUpperCase());
-};
+// src/validation/precision.ts
+var import_big_float3 = require("@awsless/big-float");
+var import_valibot6 = require("valibot");
+function precision(decimals, error) {
+  return (input) => {
+    const big = new import_big_float3.BigFloat(input.toString());
+    return -big.exponent <= decimals ? (0, import_valibot6.getOutput)(input) : (0, import_valibot6.getPipeIssues)("precision", error ?? `Invalid ${decimals} precision number`, input);
+  };
+}
 
-// src/types/array.ts
-var import_superstruct6 = require("superstruct");
-function unique(struct2, compare = (a, b) => a === b) {
-  return (0, import_superstruct6.refine)(struct2, "unique", (value) => {
-    for (const x in value) {
-      for (const y in value) {
-        if (x !== y && compare(value[x], value[y])) {
-          return `Expected a ${struct2.type} with unique values, but received "${value}"`;
+// src/validation/unique.ts
+var import_valibot7 = require("valibot");
+function unique(compare = (a, b) => a === b, error) {
+  return (input) => {
+    for (const x in input) {
+      for (const y in input) {
+        if (x !== y && compare(input[x], input[y])) {
+          return (0, import_valibot7.getPipeIssues)("unique", error ?? "None unique array", input);
         }
       }
     }
-    return true;
-  });
+    return (0, import_valibot7.getOutput)(input);
+  };
 }
-
-// src/index.ts
-var import_superstruct7 = require("superstruct");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Struct,
-  StructError,
-  any,
-  array,
-  assert,
-  assign,
   bigfloat,
-  bigint,
-  boolean,
-  coerce,
-  create,
   date,
-  defaulted,
-  define,
-  deprecated,
-  dynamic,
-  empty,
-  enums,
-  func,
-  instance,
-  integer,
-  intersection,
-  is,
   json,
-  lazy,
-  literal,
-  lowercase,
-  map,
-  mask,
-  max,
-  min,
-  never,
-  nonempty,
-  nullable,
-  number,
-  object,
-  omit,
-  optional,
-  partial,
-  pattern,
-  pick,
   positive,
   precision,
-  record,
-  refine,
-  regexp,
-  set,
-  size,
-  string,
-  struct,
-  trimmed,
-  tuple,
-  type,
-  union,
   unique,
-  unknown,
-  uppercase,
-  uuid
+  uuid,
+  ...require("valibot")
 });

package/dist/index.d.cts

@@ -0,0 +1,29 @@
+import { BaseSchema, SchemaWithTransform, StringSchema, Output, Pipe, ErrorMessage, PipeResult } from 'valibot';
+export * from 'valibot';
+import { BigFloat } from '@awsless/big-float';
+import { UUID } from 'crypto';
+
+type JsonSchema<T extends BaseSchema> = SchemaWithTransform<StringSchema, Output<T>>;
+declare const json: <T extends BaseSchema<any, any>>(schema: T) => JsonSchema<T>;
+
+type BigFloatSchema = BaseSchema<string | number | BigFloat | {
+    exponent: number;
+    coefficient: bigint;
+}, BigFloat>;
+declare function bigfloat(pipe?: Pipe<BigFloat>): BigFloatSchema;
+declare function bigfloat(error?: ErrorMessage, pipe?: Pipe<BigFloat>): BigFloatSchema;
+
+type DateSchema = BaseSchema<string | Date, Date>;
+declare function date(pipe?: Pipe<Date>): DateSchema;
+declare function date(error?: ErrorMessage, pipe?: Pipe<Date>): DateSchema;
+
+type UuidSchema = SchemaWithTransform<StringSchema | BaseSchema<UUID>, UUID>;
+declare const uuid: () => UuidSchema;
+
+declare function positive<T extends BigFloat | number>(error?: ErrorMessage): (input: T) => PipeResult<T>;
+
+declare function precision<T extends BigFloat | number>(decimals: number, error?: ErrorMessage): (input: T) => PipeResult<T>;
+
+declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number]) => boolean, error?: ErrorMessage): (input: T) => PipeResult<T>;
+
+export { bigfloat, date, json, positive, precision, unique, uuid };

package/dist/index.d.ts

@@ -1,21 +1,29 @@
-import { Struct } from 'superstruct';
-export { Coercer, Context, Describe, Failure, Infer, Refiner, Result, Struct, StructError, Validator, any, array, assert, assign, bigint, boolean, coerce, create, defaulted, define, deprecated, dynamic, empty, enums, func, instance, integer, intersection, is, lazy, literal, map, mask, max, min, never, nonempty, nullable, number, object, omit, optional, partial, pattern, pick, record, refine, regexp, set, size, string, struct, trimmed, tuple, type, union, unknown } from 'superstruct';
+import { BaseSchema, SchemaWithTransform, StringSchema, Output, Pipe, ErrorMessage, PipeResult } from 'valibot';
+export * from 'valibot';
 import { BigFloat } from '@awsless/big-float';
 import { UUID } from 'crypto';
 
-declare const bigfloat: () => Struct<BigFloat, null>;
-declare const positive: <T extends number | BigFloat, S extends unknown>(struct: Struct<T, S>) => Struct<T, S>;
-declare const precision: <T extends number | BigFloat, S extends unknown>(struct: Struct<T, S>, decimals: number) => Struct<T, S>;
+type JsonSchema<T extends BaseSchema> = SchemaWithTransform<StringSchema, Output<T>>;
+declare const json: <T extends BaseSchema<any, any>>(schema: T) => JsonSchema<T>;
 
-declare const date: () => Struct<Date, null>;
+type BigFloatSchema = BaseSchema<string | number | BigFloat | {
+    exponent: number;
+    coefficient: bigint;
+}, BigFloat>;
+declare function bigfloat(pipe?: Pipe<BigFloat>): BigFloatSchema;
+declare function bigfloat(error?: ErrorMessage, pipe?: Pipe<BigFloat>): BigFloatSchema;
 
-declare const uuid: () => Struct<UUID, null>;
+type DateSchema = BaseSchema<string | Date, Date>;
+declare function date(pipe?: Pipe<Date>): DateSchema;
+declare function date(error?: ErrorMessage, pipe?: Pipe<Date>): DateSchema;
 
-declare const json: <T, S>(struct: Struct<T, S>) => Struct<T, S>;
+type UuidSchema = SchemaWithTransform<StringSchema | BaseSchema<UUID>, UUID>;
+declare const uuid: () => UuidSchema;
 
-declare const lowercase: <T, S>(struct: Struct<T, S>) => Struct<T, S>;
-declare const uppercase: <T, S>(struct: Struct<T, S>) => Struct<T, S>;
+declare function positive<T extends BigFloat | number>(error?: ErrorMessage): (input: T) => PipeResult<T>;
 
-declare function unique<T extends any[], S extends any>(struct: Struct<T, S>, compare?: (a: T[number], b: T[number]) => boolean): Struct<T, S>;
+declare function precision<T extends BigFloat | number>(decimals: number, error?: ErrorMessage): (input: T) => PipeResult<T>;
 
-export { bigfloat, date, json, lowercase, positive, precision, unique, uppercase, uuid };
+declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number]) => boolean, error?: ErrorMessage): (input: T) => PipeResult<T>;
+
+export { bigfloat, date, json, positive, precision, unique, uuid };

package/dist/index.js

@@ -1,195 +1,133 @@
-// src/types/bigfloat.ts
-import { coerce, define, number, string, union, refine } from "superstruct";
-import { BigFloat, gt } from "@awsless/big-float";
-var bigfloat = () => {
-  const base = define("bigfloat", (value) => {
-    return value instanceof BigFloat || "Invalid number";
-  });
-  return coerce(base, union([string(), number()]), (value) => {
-    if (typeof value === "string" && value !== "" || typeof value === "number") {
-      if (!isNaN(Number(value))) {
-        return new BigFloat(value);
+// src/index.ts
+export * from "valibot";
+
+// src/schema/json.ts
+import { string, transform } from "valibot";
+var json = (schema) => {
+  return transform(
+    string(),
+    (value) => {
+      try {
+        return JSON.parse(value);
+      } catch (error) {
+        return null;
       }
-    }
-    return null;
-  });
-};
-var positive = (struct2) => {
-  const expected = `Expected a positive ${struct2.type}`;
-  const ZERO = new BigFloat(0);
-  return refine(struct2, "positive", (value) => {
-    return gt(value, ZERO) || `${expected} but received '${value}'`;
-  });
-};
-var precision = (struct2, decimals) => {
-  const expected = `Expected a ${struct2.type}`;
-  return refine(struct2, "precision", (value) => {
-    const big = new BigFloat(value);
-    return -big.exponent <= decimals || `${expected} with ${decimals} decimals`;
-  });
+    },
+    schema
+  );
 };
 
-// src/types/date.ts
-import { coerce as coerce2, date as sdate, string as string2 } from "superstruct";
-var date = () => {
-  return coerce2(sdate(), string2(), (value) => {
-    return new Date(value);
-  });
-};
+// src/schema/bigfloat.ts
+import { BigFloat } from "@awsless/big-float";
+import {
+  bigint,
+  getDefaultArgs,
+  instance,
+  number,
+  object,
+  string as string2,
+  transform as transform2,
+  union,
+  getPipeIssues,
+  getOutput
+} from "valibot";
+var make = (value) => new BigFloat(value);
+function bigfloat(arg1, arg2) {
+  const [msg, pipe] = getDefaultArgs(arg1, arg2);
+  const error = msg ?? "Invalid bigfloat";
+  return union(
+    [
+      instance(BigFloat, pipe),
+      transform2(
+        string2([
+          (input) => {
+            if (input === "" || isNaN(Number(input))) {
+              return getPipeIssues("bigfloat", error, input);
+            }
+            return getOutput(input);
+          }
+        ]),
+        make,
+        pipe
+      ),
+      transform2(number(), make, pipe),
+      transform2(
+        object({
+          exponent: number(),
+          coefficient: bigint()
+        }),
+        make,
+        pipe
+      )
+    ],
+    error
+  );
+}
 
-// src/types/uuid.ts
-import { define as define2 } from "superstruct";
+// src/schema/date.ts
+import { getDefaultArgs as getDefaultArgs2, date as base, string as string3, union as union2, transform as transform3 } from "valibot";
+function date(arg1, arg2) {
+  const [error, pipe] = getDefaultArgs2(arg1, arg2);
+  return union2(
+    [
+      base(pipe),
+      transform3(
+        string3(),
+        (input) => {
+          return new Date(input);
+        },
+        base(pipe)
+      )
+    ],
+    error ?? "Invalid date"
+  );
+}
+
+// src/schema/uuid.ts
+import { string as string4, uuid as base2, transform as transform4 } from "valibot";
 var uuid = () => {
-  return define2("uuid", (value) => {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(String(value));
-  });
+  return transform4(string4([base2()]), (v) => v);
 };
 
-// src/types/json.ts
-import { coerce as coerce3, string as string3 } from "superstruct";
-var json = (struct2) => {
-  return coerce3(struct2, string3(), (value) => {
-    try {
-      return JSON.parse(value);
-    } catch (error) {
-      return value;
-    }
-  });
-};
+// src/validation/positive.ts
+import { ZERO, gt } from "@awsless/big-float";
+import { getOutput as getOutput2, getPipeIssues as getPipeIssues2 } from "valibot";
+function positive(error) {
+  return (input) => {
+    return gt(input, ZERO) ? getOutput2(input) : getPipeIssues2("positive", error ?? "Invalid positive number", input);
+  };
+}
 
-// src/types/string.ts
-import { coerce as coerce4, string as string4 } from "superstruct";
-var lowercase = (struct2) => {
-  return coerce4(struct2, string4(), (value) => value.toLowerCase());
-};
-var uppercase = (struct2) => {
-  return coerce4(struct2, string4(), (value) => value.toUpperCase());
-};
+// src/validation/precision.ts
+import { BigFloat as BigFloat3 } from "@awsless/big-float";
+import { getOutput as getOutput3, getPipeIssues as getPipeIssues3 } from "valibot";
+function precision(decimals, error) {
+  return (input) => {
+    const big = new BigFloat3(input.toString());
+    return -big.exponent <= decimals ? getOutput3(input) : getPipeIssues3("precision", error ?? `Invalid ${decimals} precision number`, input);
+  };
+}
 
-// src/types/array.ts
-import { refine as refine2 } from "superstruct";
-function unique(struct2, compare = (a, b) => a === b) {
-  return refine2(struct2, "unique", (value) => {
-    for (const x in value) {
-      for (const y in value) {
-        if (x !== y && compare(value[x], value[y])) {
-          return `Expected a ${struct2.type} with unique values, but received "${value}"`;
+// src/validation/unique.ts
+import { getOutput as getOutput4, getPipeIssues as getPipeIssues4 } from "valibot";
+function unique(compare = (a, b) => a === b, error) {
+  return (input) => {
+    for (const x in input) {
+      for (const y in input) {
+        if (x !== y && compare(input[x], input[y])) {
+          return getPipeIssues4("unique", error ?? "None unique array", input);
         }
       }
     }
-    return true;
-  });
+    return getOutput4(input);
+  };
 }
-
-// src/index.ts
-import {
-  coerce as coerce5,
-  defaulted,
-  trimmed,
-  empty,
-  max,
-  min,
-  nonempty,
-  pattern,
-  size,
-  refine as refine3,
-  any,
-  array,
-  bigint,
-  boolean,
-  enums,
-  func,
-  instance,
-  integer,
-  intersection,
-  literal,
-  map,
-  never,
-  nullable,
-  number as number2,
-  object,
-  optional,
-  record,
-  regexp,
-  set,
-  string as string5,
-  tuple,
-  type,
-  union as union2,
-  unknown,
-  assign,
-  define as define3,
-  deprecated,
-  dynamic,
-  lazy,
-  omit,
-  partial,
-  pick,
-  struct,
-  assert,
-  create,
-  mask,
-  is,
-  Struct as Struct7,
-  StructError
-} from "superstruct";
 export {
-  Struct7 as Struct,
-  StructError,
-  any,
-  array,
-  assert,
-  assign,
   bigfloat,
-  bigint,
-  boolean,
-  coerce5 as coerce,
-  create,
   date,
-  defaulted,
-  define3 as define,
-  deprecated,
-  dynamic,
-  empty,
-  enums,
-  func,
-  instance,
-  integer,
-  intersection,
-  is,
   json,
-  lazy,
-  literal,
-  lowercase,
-  map,
-  mask,
-  max,
-  min,
-  never,
-  nonempty,
-  nullable,
-  number2 as number,
-  object,
-  omit,
-  optional,
-  partial,
-  pattern,
-  pick,
   positive,
   precision,
-  record,
-  refine3 as refine,
-  regexp,
-  set,
-  size,
-  string5 as string,
-  struct,
-  trimmed,
-  tuple,
-  type,
-  union2 as union,
   unique,
-  unknown,
-  uppercase,
   uuid
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awsless/validate",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -24,13 +24,13 @@
     }
   },
   "peerDependencies": {
-    "@awsless/big-float": "^0.0.2"
+    "@awsless/big-float": "^0.0.4"
   },
   "devDependencies": {
-    "@awsless/big-float": "^0.0.2"
+    "@awsless/big-float": "^0.0.4"
   },
   "dependencies": {
-    "superstruct": "^1.0.3"
+    "valibot": "^0.20.1"
   },
   "scripts": {
     "test": "pnpm code test",