decoders 2.2.0-test → 2.2.0-test2

package/dist/index.mjs

@@ -0,0 +1,659 @@
+import {
+  asDate,
+  formatInline,
+  indent,
+  isPojo,
+  lazyval,
+  subtract,
+  summarize
+} from "./chunk-ZTKFAKRL.mjs";
+import {
+  err,
+  ok
+} from "./chunk-HBFFQIIN.mjs";
+
+// src/annotate.ts
+var _register = /* @__PURE__ */ new WeakSet();
+function brand(ann) {
+  _register.add(ann);
+  return ann;
+}
+function object(fields, text) {
+  return brand({ type: "object", fields, text });
+}
+function array(items, text) {
+  return brand({
+    type: "array",
+    items,
+    text
+  });
+}
+function func(text) {
+  return brand({
+    type: "function",
+    text
+  });
+}
+function unknown(value, text) {
+  return brand({
+    type: "unknown",
+    value,
+    text
+  });
+}
+function scalar(value, text) {
+  return brand({
+    type: "scalar",
+    value,
+    text
+  });
+}
+function circularRef(text) {
+  return brand({
+    type: "circular-ref",
+    text
+  });
+}
+function updateText(annotation, text) {
+  if (text !== void 0) {
+    return brand({ ...annotation, text });
+  } else {
+    return annotation;
+  }
+}
+function merge(objAnnotation, fields) {
+  const newFields = { ...objAnnotation.fields, ...fields };
+  return object(newFields, objAnnotation.text);
+}
+function asAnnotation(thing) {
+  return typeof thing === "object" && thing !== null && _register.has(thing) ? thing : void 0;
+}
+function annotateArray(value, text, seen) {
+  seen.add(value);
+  const items = value.map((v) => annotate(v, void 0, seen));
+  return array(items, text);
+}
+function annotateObject(obj, text, seen) {
+  seen.add(obj);
+  const fields = {};
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    fields[key] = annotate(value, void 0, seen);
+  }
+  return object(fields, text);
+}
+function annotate(value, text, seen) {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "symbol" || typeof value.getMonth === "function") {
+    return scalar(value, text);
+  }
+  const ann = asAnnotation(value);
+  if (ann) {
+    return updateText(ann, text);
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      return circularRef(text);
+    } else {
+      return annotateArray(value, text, seen);
+    }
+  }
+  if (isPojo(value)) {
+    if (seen.has(value)) {
+      return circularRef(text);
+    } else {
+      return annotateObject(value, text, seen);
+    }
+  }
+  if (typeof value === "function") {
+    return func(text);
+  }
+  return unknown(value, text);
+}
+function public_annotate(value, text) {
+  return annotate(value, text, /* @__PURE__ */ new WeakSet());
+}
+function public_annotateObject(obj, text) {
+  return annotateObject(obj, text, /* @__PURE__ */ new WeakSet());
+}
+
+// src/Decoder.ts
+function noThrow(fn) {
+  return (t) => {
+    try {
+      const v = fn(t);
+      return ok(v);
+    } catch (e) {
+      return err(public_annotate(t, e instanceof Error ? e.message : String(e)));
+    }
+  };
+}
+function format(err2, formatter) {
+  const formatted = formatter(err2);
+  if (typeof formatted === "string") {
+    const err3 = new Error(`
+${formatted}`);
+    err3.name = "Decoding error";
+    return err3;
+  } else {
+    return formatted;
+  }
+}
+function define(fn) {
+  function decode(blob) {
+    return fn(
+      blob,
+      ok,
+      (msg) => err(typeof msg === "string" ? public_annotate(blob, msg) : msg)
+    );
+  }
+  function verify(blob, formatter = formatInline) {
+    const result = decode(blob);
+    if (result.ok) {
+      return result.value;
+    } else {
+      throw format(result.error, formatter);
+    }
+  }
+  function value(blob) {
+    return decode(blob).value;
+  }
+  function transform(transformFn) {
+    return then(noThrow(transformFn));
+  }
+  function refine(predicateFn, errmsg) {
+    return reject(
+      (value2) => predicateFn(value2) ? (
+        // Don't reject
+        null
+      ) : (
+        // Reject with the given error message
+        errmsg
+      )
+    );
+  }
+  function then(next) {
+    return define((blob, ok2, err2) => {
+      const result = decode(blob);
+      return result.ok ? next(result.value, ok2, err2) : result;
+    });
+  }
+  function reject(rejectFn) {
+    return then((value2, ok2, err2) => {
+      const errmsg = rejectFn(value2);
+      return errmsg === null ? ok2(value2) : err2(typeof errmsg === "string" ? public_annotate(value2, errmsg) : errmsg);
+    });
+  }
+  function describe(message) {
+    return define((blob, _, err2) => {
+      const result = decode(blob);
+      if (result.ok) {
+        return result;
+      } else {
+        return err2(public_annotate(result.error, message));
+      }
+    });
+  }
+  function peek_UNSTABLE(next) {
+    return define((blob, ok2, err2) => {
+      const result = decode(blob);
+      return result.ok ? next([blob, result.value], ok2, err2) : result;
+    });
+  }
+  return Object.freeze({
+    verify,
+    value,
+    decode,
+    transform,
+    refine,
+    reject,
+    describe,
+    then,
+    // EXPERIMENTAL - please DO NOT rely on this method
+    peek_UNSTABLE
+  });
+}
+
+// src/lib/objects.ts
+var pojo = define(
+  (blob, ok2, err2) => isPojo(blob) ? ok2(blob) : err2("Must be an object")
+);
+function object2(decodersByKey) {
+  const knownKeys = new Set(Object.keys(decodersByKey));
+  return pojo.then((plainObj, ok2, err2) => {
+    const actualKeys = new Set(Object.keys(plainObj));
+    const missingKeys = subtract(knownKeys, actualKeys);
+    const record = {};
+    let errors = null;
+    for (const key of Object.keys(decodersByKey)) {
+      const decoder = decodersByKey[key];
+      const rawValue = plainObj[key];
+      const result = decoder.decode(rawValue);
+      if (result.ok) {
+        const value = result.value;
+        if (value !== void 0) {
+          record[key] = value;
+        }
+        missingKeys.delete(key);
+      } else {
+        const ann = result.error;
+        if (rawValue === void 0) {
+          missingKeys.add(key);
+        } else {
+          if (errors === null) {
+            errors = {};
+          }
+          errors[key] = ann;
+        }
+      }
+    }
+    if (errors || missingKeys.size > 0) {
+      let objAnn = public_annotateObject(plainObj);
+      if (errors) {
+        objAnn = merge(objAnn, errors);
+      }
+      if (missingKeys.size > 0) {
+        const errMsg = Array.from(missingKeys).map((key) => `"${key}"`).join(", ");
+        const pluralized = missingKeys.size > 1 ? "keys" : "key";
+        objAnn = updateText(objAnn, `Missing ${pluralized}: ${errMsg}`);
+      }
+      return err2(objAnn);
+    }
+    return ok2(record);
+  });
+}
+function exact(decodersByKey) {
+  const allowedKeys = new Set(Object.keys(decodersByKey));
+  const checked = pojo.reject((plainObj) => {
+    const actualKeys = new Set(Object.keys(plainObj));
+    const extraKeys = subtract(actualKeys, allowedKeys);
+    return extraKeys.size > 0 ? `Unexpected extra keys: ${Array.from(extraKeys).join(", ")}` : (
+      // Don't reject
+      null
+    );
+  });
+  return checked.then(object2(decodersByKey).decode);
+}
+function inexact(decodersByKey) {
+  return pojo.then((plainObj) => {
+    const allkeys = new Set(Object.keys(plainObj));
+    const decoder = object2(decodersByKey).transform((safepart) => {
+      const safekeys = new Set(Object.keys(decodersByKey));
+      for (const k of safekeys)
+        allkeys.add(k);
+      const rv = {};
+      for (const k of allkeys) {
+        if (safekeys.has(k)) {
+          const value = safepart[k];
+          if (value !== void 0) {
+            rv[k] = value;
+          }
+        } else {
+          rv[k] = plainObj[k];
+        }
+      }
+      return rv;
+    });
+    return decoder.decode(plainObj);
+  });
+}
+function dict(decoder) {
+  return pojo.then((plainObj, ok2, err2) => {
+    let rv = {};
+    let errors = null;
+    for (const key of Object.keys(plainObj)) {
+      const value = plainObj[key];
+      const result = decoder.decode(value);
+      if (result.ok) {
+        if (errors === null) {
+          rv[key] = result.value;
+        }
+      } else {
+        rv = {};
+        if (errors === null) {
+          errors = {};
+        }
+        errors[key] = result.error;
+      }
+    }
+    if (errors !== null) {
+      return err2(merge(public_annotateObject(plainObj), errors));
+    } else {
+      return ok2(rv);
+    }
+  });
+}
+function mapping(decoder) {
+  return dict(decoder).transform(
+    (obj) => new Map(
+      // This is effectively Object.entries(obj), but in a way that Flow
+      // will know the types are okay
+      Object.keys(obj).map((key) => [key, obj[key]])
+    )
+  );
+}
+
+// src/lib/utilities.ts
+function instanceOf(klass) {
+  return define(
+    (blob, ok2, err2) => blob instanceof klass ? ok2(blob) : err2(`Must be ${klass.name} instance`)
+  );
+}
+function lazy(decoderFn) {
+  return define((blob) => decoderFn().decode(blob));
+}
+function prep(mapperFn, decoder) {
+  return define((originalInput, _, err2) => {
+    let blob;
+    try {
+      blob = mapperFn(originalInput);
+    } catch (e) {
+      return err2(
+        public_annotate(
+          originalInput,
+          // istanbul ignore next
+          e instanceof Error ? e.message : String(e)
+        )
+      );
+    }
+    const r = decoder.decode(blob);
+    return r.ok ? r : err2(public_annotate(originalInput, r.error.text));
+  });
+}
+function never(msg) {
+  return define((_, __, err2) => err2(msg));
+}
+var fail = never;
+
+// src/lib/unions.ts
+var EITHER_PREFIX = "Either:\n";
+function itemize(s) {
+  return `-${indent(s).substring(1)}`;
+}
+function nest(errText) {
+  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
+}
+function either(...decoders) {
+  if (decoders.length === 0) {
+    throw new Error("Pass at least one decoder to either()");
+  }
+  return define((blob, _, err2) => {
+    const errors = [];
+    for (let i = 0; i < decoders.length; i++) {
+      const result = decoders[i].decode(blob);
+      if (result.ok) {
+        return result;
+      } else {
+        errors.push(result.error);
+      }
+    }
+    const text = EITHER_PREFIX + errors.map((err3) => nest(summarize(err3).join("\n"))).join("\n");
+    return err2(text);
+  });
+}
+function oneOf(constants) {
+  return define((blob, ok2, err2) => {
+    const winner = constants.find((c) => c === blob);
+    if (winner !== void 0) {
+      return ok2(winner);
+    }
+    return err2(
+      `Must be one of ${constants.map((value) => JSON.stringify(value)).join(", ")}`
+    );
+  });
+}
+function taggedUnion(field, mapping2) {
+  const base = object2({
+    [field]: prep(String, oneOf(Object.keys(mapping2)))
+  }).transform((o) => o[field]);
+  return base.peek_UNSTABLE(([blob, key]) => {
+    const decoder = mapping2[key];
+    return decoder.decode(blob);
+  });
+}
+
+// src/lib/basics.ts
+var null_ = define(
+  (blob, ok2, err2) => blob === null ? ok2(blob) : err2("Must be null")
+);
+var undefined_ = define(
+  (blob, ok2, err2) => blob === void 0 ? ok2(blob) : err2("Must be undefined")
+);
+var undefined_or_null = define(
+  (blob, ok2, err2) => blob === void 0 || blob === null ? ok2(blob) : (
+    // Combine error message into a single line for readability
+    err2("Must be undefined or null")
+  )
+);
+function optional(decoder, defaultValue) {
+  const rv = either(undefined_, decoder);
+  return arguments.length >= 2 ? rv.transform((value) => value ?? lazyval(defaultValue)) : rv;
+}
+function nullable(decoder, defaultValue) {
+  const rv = either(null_, decoder);
+  return arguments.length >= 2 ? rv.transform((value) => value ?? lazyval(defaultValue)) : rv;
+}
+function maybe(decoder, defaultValue) {
+  const rv = either(undefined_or_null, decoder);
+  return arguments.length >= 2 ? rv.transform((value) => value ?? lazyval(defaultValue)) : rv;
+}
+function constant(value) {
+  return define(
+    (blob, ok2, err2) => blob === value ? ok2(value) : err2(`Must be constant ${String(value)}`)
+  );
+}
+function always(value) {
+  return define(
+    typeof value === "function" ? (_, ok2) => ok2(value()) : (_, ok2) => ok2(value)
+  );
+}
+var hardcoded = always;
+var unknown2 = define((blob, ok2, _) => ok2(blob));
+var mixed = unknown2;
+
+// src/lib/arrays.ts
+var poja = define((blob, ok2, err2) => {
+  if (!Array.isArray(blob)) {
+    return err2("Must be an array");
+  }
+  return ok2(blob);
+});
+function all(items, blobs, ok2, err2) {
+  const results = [];
+  for (let index = 0; index < items.length; ++index) {
+    const result = items[index];
+    if (result.ok) {
+      results.push(result.value);
+    } else {
+      const ann = result.error;
+      const clone = blobs.slice();
+      clone.splice(
+        index,
+        1,
+        public_annotate(ann, ann.text ? `${ann.text} (at index ${index})` : `index ${index}`)
+      );
+      return err2(public_annotate(clone));
+    }
+  }
+  return ok2(results);
+}
+function array2(decoder) {
+  const decodeFn = decoder.decode;
+  return poja.then((blobs, ok2, err2) => {
+    const results = blobs.map(decodeFn);
+    return all(results, blobs, ok2, err2);
+  });
+}
+function isNonEmpty(arr) {
+  return arr.length > 0;
+}
+function nonEmptyArray(decoder) {
+  return array2(decoder).refine(isNonEmpty, "Must be non-empty array");
+}
+function set(decoder) {
+  return array2(decoder).transform((items) => new Set(items));
+}
+var ntuple = (n) => poja.refine((arr) => arr.length === n, `Must be a ${n}-tuple`);
+function tuple(...decoders) {
+  return ntuple(decoders.length).then((blobs, ok2, err2) => {
+    let allOk = true;
+    const rvs = decoders.map((decoder, i) => {
+      const blob = blobs[i];
+      const result = decoder.decode(blob);
+      if (result.ok) {
+        return result.value;
+      } else {
+        allOk = false;
+        return result.error;
+      }
+    });
+    if (allOk) {
+      return ok2(rvs);
+    } else {
+      return err2(public_annotate(rvs));
+    }
+  });
+}
+
+// src/lib/numbers.ts
+var anyNumber = define(
+  (blob, ok2, err2) => typeof blob === "number" ? ok2(blob) : err2("Must be number")
+);
+var number = anyNumber.refine(
+  (n) => Number.isFinite(n),
+  "Number must be finite"
+);
+var integer = number.refine(
+  (n) => Number.isInteger(n),
+  "Number must be an integer"
+);
+var positiveNumber = number.refine((n) => n >= 0, "Number must be positive").transform(Math.abs);
+var positiveInteger = integer.refine((n) => n >= 0, "Number must be positive").transform(Math.abs);
+
+// src/lib/booleans.ts
+var boolean = define((blob, ok2, err2) => {
+  return typeof blob === "boolean" ? ok2(blob) : err2("Must be boolean");
+});
+var truthy = define((blob, ok2, _) => ok2(!!blob));
+var numericBoolean = number.transform((n) => !!n);
+
+// src/lib/strings.ts
+var url_re = /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,/\w]*)?(?:#[.,!/\w]*)?)?$/;
+var string = define(
+  (blob, ok2, err2) => typeof blob === "string" ? ok2(blob) : err2("Must be string")
+);
+var nonEmptyString = regex(/\S/, "Must be non-empty string");
+function regex(regex2, msg) {
+  return string.refine((s) => regex2.test(s), msg);
+}
+var email = regex(
+  // The almost perfect email regex, taken from https://emailregex.com/
+  /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
+  "Must be email"
+);
+var url = either(
+  regex(url_re, "Must be URL").transform((value) => new URL(value)),
+  instanceOf(URL)
+);
+var httpsUrl = url.refine(
+  (value) => value.protocol === "https:",
+  "Must be an HTTPS URL"
+);
+var uuid = regex(
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+  "Must be uuid"
+);
+var uuidv1 = (
+  // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)
+  uuid.refine((value) => value[14] === "1", "Must be uuidv1")
+);
+var uuidv4 = (
+  // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
+  uuid.refine((value) => value[14] === "4", "Must be uuidv4")
+);
+
+// src/lib/dates.ts
+var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
+var date = define((blob, ok2, err2) => {
+  const date2 = asDate(blob);
+  return date2 !== null ? ok2(date2) : err2("Must be a Date");
+});
+var iso8601 = (
+  // Input itself needs to match the ISO8601 regex...
+  regex(iso8601_re, "Must be ISO8601 format").transform(
+    // Make sure it is a _valid_ date
+    (value) => {
+      const date2 = new Date(value);
+      if (isNaN(date2.getTime())) {
+        throw new Error("Must be valid date/time value");
+      }
+      return date2;
+    }
+  )
+);
+
+// src/lib/json.ts
+var jsonObject = lazy(() => dict(json));
+var jsonArray = lazy(() => array2(json));
+var json = either(
+  null_,
+  string,
+  number,
+  boolean,
+  jsonObject,
+  jsonArray
+).describe("Must be valid JSON value");
+export {
+  always,
+  anyNumber,
+  array2 as array,
+  boolean,
+  constant,
+  date,
+  define,
+  dict,
+  either,
+  email,
+  exact,
+  fail,
+  hardcoded,
+  httpsUrl,
+  inexact,
+  instanceOf,
+  integer,
+  iso8601,
+  json,
+  jsonArray,
+  jsonObject,
+  lazy,
+  mapping,
+  maybe,
+  mixed,
+  never,
+  nonEmptyArray,
+  nonEmptyString,
+  null_,
+  nullable,
+  number,
+  numericBoolean,
+  object2 as object,
+  oneOf,
+  optional,
+  poja,
+  pojo,
+  positiveInteger,
+  positiveNumber,
+  prep,
+  regex,
+  set,
+  string,
+  taggedUnion,
+  truthy,
+  tuple,
+  undefined_,
+  unknown2 as unknown,
+  url,
+  uuid,
+  uuidv1,
+  uuidv4
+};
+//# sourceMappingURL=index.mjs.map