q-type 0.1.2

package/dist/index.cjs

@@ -0,0 +1,602 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  q: () => q,
+  isPositioned: () => isPositioned,
+  QtypeParseError: () => QtypeParseError,
+  QUnion: () => QUnion,
+  QType: () => QType,
+  QTuple: () => QTuple,
+  QTransform: () => QTransform,
+  QString: () => QString,
+  QSchema: () => QSchema,
+  QPositioned: () => QPositioned,
+  QOptional: () => QOptional,
+  QObject: () => QObject,
+  QNumber: () => QNumber,
+  QNullable: () => QNullable,
+  QLiteral: () => QLiteral,
+  QInteger: () => QInteger,
+  QEnum: () => QEnum,
+  QDefault: () => QDefault,
+  QDate: () => QDate,
+  QBoolean: () => QBoolean,
+  QArray: () => QArray
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/types.ts
+class QType {
+}
+// src/errors.ts
+class QtypeParseError extends Error {
+  key;
+  path;
+  rawValue;
+  constructor(message, ctx) {
+    super(`[Qtype] ${ctx.path}: ${message} (got "${ctx.raw}")`);
+    this.name = "QtypeParseError";
+    this.key = ctx.key;
+    this.path = ctx.path;
+    this.rawValue = ctx.raw;
+  }
+}
+// src/primitives.ts
+class QString extends QType {
+  kind = "string";
+  decode(raw, ctx) {
+    if (raw === "") {
+      throw new QtypeParseError("required segment is empty", ctx);
+    }
+    return raw;
+  }
+  encode(value, _opts) {
+    return value;
+  }
+}
+
+class QNumber extends QType {
+  kind = "number";
+  decode(raw, ctx) {
+    if (raw === "") {
+      throw new QtypeParseError("required segment is empty", ctx);
+    }
+    const n = Number(raw);
+    if (Number.isNaN(n)) {
+      throw new QtypeParseError(`"${raw}" is not a valid number`, ctx);
+    }
+    return n;
+  }
+  encode(value, _opts) {
+    return String(value);
+  }
+}
+
+class QInteger extends QType {
+  kind = "integer";
+  radix;
+  constructor(radix = 10) {
+    super();
+    this.radix = radix;
+  }
+  decode(raw, ctx) {
+    if (raw === "") {
+      throw new QtypeParseError("required segment is empty", ctx);
+    }
+    const n = parseInt(raw, this.radix);
+    if (Number.isNaN(n)) {
+      throw new QtypeParseError(`"${raw}" is not a valid integer`, ctx);
+    }
+    return n;
+  }
+  encode(value, _opts) {
+    return value.toString(this.radix);
+  }
+}
+
+class QBoolean extends QType {
+  kind = "boolean";
+  truthy;
+  constructor(truthy = ["1", "true", "Y", "y"]) {
+    super();
+    this.truthy = truthy;
+  }
+  decode(raw, ctx) {
+    if (raw === "") {
+      throw new QtypeParseError("required segment is empty", ctx);
+    }
+    return this.truthy.includes(raw);
+  }
+  encode(value, _opts) {
+    return value ? this.truthy[0] ?? "1" : "0";
+  }
+}
+
+class QDate extends QType {
+  kind = "date";
+  format;
+  constructor(format = "iso") {
+    super();
+    this.format = format;
+  }
+  decode(raw, ctx) {
+    if (raw === "") {
+      throw new QtypeParseError("required segment is empty", ctx);
+    }
+    let d;
+    if (this.format === "yyyyMMdd") {
+      if (!/^\d{8}$/.test(raw)) {
+        throw new QtypeParseError(`"${raw}" does not match yyyyMMdd`, ctx);
+      }
+      const Y = parseInt(raw.slice(0, 4), 10);
+      const M = parseInt(raw.slice(4, 6), 10) - 1;
+      const D = parseInt(raw.slice(6, 8), 10);
+      d = new Date(Y, M, D);
+    } else {
+      d = new Date(raw);
+    }
+    if (Number.isNaN(d.getTime())) {
+      throw new QtypeParseError(`"${raw}" is not a valid date`, ctx);
+    }
+    return d;
+  }
+  encode(value, _opts) {
+    if (this.format === "yyyyMMdd") {
+      const y = value.getFullYear();
+      const m = String(value.getMonth() + 1).padStart(2, "0");
+      const d = String(value.getDate()).padStart(2, "0");
+      return `${y}${m}${d}`;
+    }
+    return value.toISOString();
+  }
+}
+
+class QLiteral extends QType {
+  kind = "literal";
+  value;
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  decode(raw, ctx) {
+    if (raw !== String(this.value)) {
+      throw new QtypeParseError(`expected literal "${String(this.value)}", got "${raw}"`, ctx);
+    }
+    return this.value;
+  }
+  encode(value, _opts) {
+    return String(value);
+  }
+}
+
+class QEnum extends QType {
+  kind = "enum";
+  values;
+  constructor(values) {
+    super();
+    this.values = values;
+  }
+  decode(raw, ctx) {
+    if (raw === "" || !this.values.includes(raw)) {
+      throw new QtypeParseError(`"${raw}" is not one of [${this.values.join(", ")}]`, ctx);
+    }
+    return raw;
+  }
+  encode(value, _opts) {
+    return value;
+  }
+}
+// src/combinators.ts
+class QOptional extends QType {
+  kind = "optional";
+  inner;
+  constructor(schema) {
+    super();
+    this.inner = schema;
+  }
+  decode(raw, ctx) {
+    if (raw === "")
+      return;
+    return this.inner.decode(raw, ctx);
+  }
+  encode(value, _opts) {
+    if (value === undefined)
+      return "";
+    return this.inner.encode(value);
+  }
+}
+
+class QNullable extends QType {
+  kind = "nullable";
+  inner;
+  constructor(schema) {
+    super();
+    this.inner = schema;
+  }
+  decode(raw, ctx) {
+    if (raw === "")
+      return null;
+    return this.inner.decode(raw, ctx);
+  }
+  encode(value, _opts) {
+    if (value === null)
+      return "";
+    return this.inner.encode(value);
+  }
+}
+
+class QDefault extends QType {
+  kind = "default";
+  inner;
+  defaultValue;
+  constructor(schema, defaultValue) {
+    super();
+    this.inner = schema;
+    this.defaultValue = defaultValue;
+  }
+  decode(raw, ctx) {
+    if (raw === "")
+      return this.defaultValue;
+    return this.inner.decode(raw, ctx);
+  }
+  encode(value, _opts) {
+    return this.inner.encode(value);
+  }
+}
+
+class QTransform extends QType {
+  kind = "transform";
+  inner;
+  decodeFn;
+  encodeFn;
+  constructor(schema, decodeFn, encodeFn) {
+    super();
+    this.inner = schema;
+    this.decodeFn = decodeFn;
+    this.encodeFn = encodeFn;
+  }
+  decode(raw, ctx) {
+    return this.decodeFn(this.inner.decode(raw, ctx));
+  }
+  encode(value, opts) {
+    return this.inner.encode(this.encodeFn(value), opts);
+  }
+}
+
+class QPositioned extends QType {
+  kind = "positioned";
+  index;
+  inner;
+  constructor(index, schema) {
+    super();
+    this.index = index;
+    this.inner = schema;
+  }
+  decode(raw, ctx) {
+    return this.inner.decode(raw, ctx);
+  }
+  encode(value, opts) {
+    return this.inner.encode(value, opts);
+  }
+}
+function isPositioned(schema) {
+  return schema.kind === "positioned";
+}
+// src/compound.ts
+class QArray extends QType {
+  kind = "array";
+  element;
+  sep;
+  constructor(schema, opts) {
+    super();
+    this.element = schema;
+    this.sep = opts?.sep ?? ";";
+  }
+  decode(raw, ctx) {
+    if (raw === "")
+      return [];
+    return raw.split(this.sep).map((part, i) => this.element.decode(part, {
+      key: `${ctx.key}[${i}]`,
+      path: `${ctx.path}[${i}]`,
+      raw: part
+    }));
+  }
+  encode(value, _opts) {
+    return value.map((v) => this.element.encode(v)).join(this.sep);
+  }
+}
+
+class QObject extends QType {
+  kind = "object";
+  properties;
+  sep;
+  kvSep;
+  constructor(properties, opts) {
+    super();
+    this.properties = properties;
+    this.sep = opts?.sep ?? ";";
+    this.kvSep = opts?.kvSep ?? ":";
+  }
+  decode(raw, ctx) {
+    const result = {};
+    if (raw === "") {
+      throw new QtypeParseError("empty segment for Object", ctx);
+    }
+    const pairs = raw.split(this.sep);
+    const seen = new Set;
+    for (const pair of pairs) {
+      const idx = pair.indexOf(this.kvSep);
+      if (idx === -1) {
+        throw new QtypeParseError(`"${pair}" is not a valid key-value pair (expected "${this.kvSep}" separator)`, ctx);
+      }
+      const key = pair.slice(0, idx);
+      const value = pair.slice(idx + 1);
+      if (!(key in this.properties)) {
+        throw new QtypeParseError(`unknown key "${key}"`, {
+          ...ctx,
+          key: `${ctx.key}.${key}`
+        });
+      }
+      seen.add(key);
+      const schema = this.properties[key];
+      result[key] = schema.decode(value, {
+        key: `${ctx.key}.${key}`,
+        path: `${ctx.path}.${key}`,
+        raw: value
+      });
+    }
+    for (const key of Object.keys(this.properties)) {
+      if (!seen.has(key)) {
+        const schema = this.properties[key];
+        result[key] = schema.decode("", {
+          key: `${ctx.key}.${key}`,
+          path: `${ctx.path}.${key}`,
+          raw: ""
+        });
+      }
+    }
+    return result;
+  }
+  encode(value, _opts) {
+    const parts = [];
+    for (const [key, schema] of Object.entries(this.properties)) {
+      const v = value[key];
+      if (v === undefined || v === null)
+        continue;
+      parts.push(`${key}${this.kvSep}${schema.encode(v)}`);
+    }
+    return parts.join(this.sep);
+  }
+}
+
+class QTuple extends QType {
+  kind = "tuple";
+  items;
+  sep;
+  constructor(items, opts) {
+    super();
+    this.items = items;
+    this.sep = opts?.sep ?? ";";
+  }
+  decode(raw, ctx) {
+    if (raw === "") {
+      throw new QtypeParseError("empty segment for Tuple", ctx);
+    }
+    const parts = raw.split(this.sep);
+    if (parts.length < this.items.length) {
+      throw new QtypeParseError(`tuple expected ${this.items.length} elements but got ${parts.length}`, ctx);
+    }
+    return this.items.map((schema, i) => schema.decode(parts[i] ?? "", {
+      key: `${ctx.key}[${i}]`,
+      path: `${ctx.path}[${i}]`,
+      raw: parts[i] ?? ""
+    }));
+  }
+  encode(value, _opts) {
+    return this.items.map((schema, i) => schema.encode(value[i])).join(this.sep);
+  }
+}
+
+class QSchema extends QType {
+  kind = "schema";
+  properties;
+  delimiter;
+  positions;
+  constructor(properties, opts) {
+    super();
+    this.properties = properties;
+    this.delimiter = opts?.delimiter ?? "|";
+    const entries = Object.entries(properties);
+    const explicitPos = new Set(entries.filter(([, s]) => isPositioned(s)).map(([, s]) => s.index));
+    const map = new Map;
+    let nextAuto = 0;
+    for (const [key, schema] of entries) {
+      if (isPositioned(schema)) {
+        map.set(key, schema.index);
+      } else {
+        while (explicitPos.has(nextAuto))
+          nextAuto++;
+        map.set(key, nextAuto);
+        nextAuto++;
+      }
+    }
+    this.positions = map;
+  }
+  parse(raw) {
+    return this.decode(raw, { key: "$", path: "$", raw });
+  }
+  safeParse(raw) {
+    try {
+      return { success: true, data: this.parse(raw) };
+    } catch (err) {
+      if (err instanceof QtypeParseError) {
+        return { success: false, error: err };
+      }
+      throw err;
+    }
+  }
+  decode(raw, ctx) {
+    const segments = raw.split(this.delimiter);
+    const result = {};
+    for (const [key, schema] of Object.entries(this.properties)) {
+      const pos = this.positions.get(key);
+      const segment = segments[pos] ?? "";
+      try {
+        result[key] = schema.decode(segment, {
+          key,
+          path: ctx.path !== "$" ? `${ctx.path}.${key}` : key,
+          raw: segment
+        });
+      } catch (err) {
+        if (err instanceof QtypeParseError)
+          throw err;
+        throw new QtypeParseError(err instanceof Error ? err.message : String(err), {
+          key,
+          path: ctx.path !== "$" ? `${ctx.path}.${key}` : key,
+          raw: segment
+        });
+      }
+    }
+    return result;
+  }
+  encode(value, opts) {
+    const entries = Object.entries(this.properties);
+    const indices = entries.map(([key]) => this.positions.get(key));
+    const maxIndex = indices.length > 0 ? Math.max(...indices) : -1;
+    const width = Math.max(opts?.length ?? 0, maxIndex + 1);
+    const out = new Array(width).fill("");
+    for (const [key, schema] of entries) {
+      const pos = this.positions.get(key);
+      out[pos] = schema.encode(value[key]);
+    }
+    return out.join(this.delimiter);
+  }
+  serialize(value, opts) {
+    return this.encode(value, opts);
+  }
+}
+// src/union.ts
+class QUnion extends QType {
+  kind = "union";
+  variants;
+  discriminator;
+  constructor(variants, opts) {
+    super();
+    this.variants = variants;
+    this.discriminator = opts?.discriminator;
+  }
+  parse(raw) {
+    return this.decode(raw, { key: "$", path: "$", raw });
+  }
+  safeParse(raw) {
+    try {
+      return { success: true, data: this.parse(raw) };
+    } catch (err) {
+      if (err instanceof QtypeParseError)
+        return { success: false, error: err };
+      throw err;
+    }
+  }
+  decode(raw, ctx) {
+    const errors = [];
+    for (const variant of this.variants) {
+      try {
+        return variant.decode(raw, ctx);
+      } catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+      }
+    }
+    throw new QtypeParseError(`no variant matched: ${errors.join("; ")}`, ctx);
+  }
+  encode(value, opts) {
+    for (const variant of this.variants) {
+      try {
+        return variant.encode(value, opts);
+      } catch {
+        continue;
+      }
+    }
+    throw new Error("QUnion: no variant could encode the value");
+  }
+  serialize(value, opts) {
+    return this.encode(value, opts);
+  }
+  match(value) {
+    if (!this.discriminator)
+      return;
+    for (const variant of this.variants) {
+      if (variant instanceof QSchema) {
+        const props = variant.properties;
+        const discSchema = props[this.discriminator];
+        if (!discSchema)
+          continue;
+        if (discSchema instanceof QLiteral && String(discSchema.value) === value) {
+          return variant;
+        }
+        if (discSchema instanceof QEnum && discSchema.values.includes(value)) {
+          return variant;
+        }
+      }
+    }
+    return;
+  }
+}
+// src/index.ts
+var q = {
+  String: () => new QString,
+  Number: () => new QNumber,
+  Integer: (radix) => new QInteger(radix),
+  Boolean: (truthy) => new QBoolean(truthy),
+  Date: (format) => new QDate(format),
+  Literal: (value) => new QLiteral(value),
+  Enum: (values) => new QEnum(values),
+  Array: (schema, opts) => new QArray(schema, opts),
+  Object: (props, opts) => new QObject(props, opts),
+  Tuple: (items, opts) => new QTuple(items, opts),
+  Schema: (props, opts) => new QSchema(props, opts),
+  Optional: (schema) => new QOptional(schema),
+  Nullable: (schema) => new QNullable(schema),
+  Default: (schema, defaultValue) => new QDefault(schema, defaultValue),
+  Transform: (schema, decode, encode) => new QTransform(schema, decode, encode),
+  at: (index, schema) => new QPositioned(index, schema),
+  Union: (variants, opts) => new QUnion(variants, opts)
+};