@sleekcms/json-zen 1.0.0 → 1.1.1

package/lib/esm/index.js

@@ -0,0 +1,382 @@
+// src/lib.ts
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string" || value instanceof String;
+}
+function isNumber(value) {
+  return typeof value === "number" || value instanceof Number;
+}
+function isBoolean(value) {
+  return typeof value === "boolean" || value instanceof Boolean;
+}
+function isRegExp(value) {
+  return value instanceof RegExp;
+}
+
+// src/types.ts
+var ZenTypes = class _ZenTypes {
+  static {
+    this.ALIASES = {
+      "s": "string",
+      "n": "number",
+      "b": "boolean"
+    };
+  }
+  static {
+    this.TYPES = {
+      "string": (v) => v !== void 0 ? isString(v) : "",
+      "number": (v) => v !== void 0 ? isNumber(v) : 0,
+      "boolean": (v) => v !== void 0 ? isBoolean(v) : true,
+      "null": (v) => v !== void 0 ? v === null : null
+    };
+  }
+  constructor(types) {
+    this.types = Object.assign({}, _ZenTypes.TYPES);
+    if (types) {
+      for (const k in types) {
+        if (k.match(/^_/)) continue;
+        const fn = types[k];
+        this.types[k] = _ZenTypes._toType(fn);
+      }
+    }
+  }
+  static _toType(fn) {
+    if (isArray(fn)) {
+      const lookup = fn;
+      return (v) => {
+        if (v !== void 0) return !isString(v) || lookup.indexOf(v) >= 0;
+        else return lookup[Math.random() * lookup.length | 0];
+      };
+    } else if (isRegExp(fn)) {
+      const regex = fn;
+      return (v) => {
+        if (v !== void 0) return !isString(v) || regex.test(v);
+        else return regex.source.replace(/\\(.)/g, "$1");
+      };
+    }
+    return fn;
+  }
+  static extend(obj) {
+    for (const k in obj) {
+      this.TYPES[k] = this._toType(obj[k]);
+    }
+  }
+  static toSchema(obj) {
+    if (obj === null) return "?";
+    if (obj === void 0) return "?";
+    if (isArray(obj)) return "array";
+    if (isObject(obj)) return "object";
+    if (isString(obj)) return "string";
+    if (isBoolean(obj)) return "boolean";
+    if (isNumber(obj)) return "number";
+    return "?";
+  }
+  resolve(k) {
+    return _ZenTypes.ALIASES[k] ?? k;
+  }
+  sample(k) {
+    if (!this.has(k)) return null;
+    return this.types[this.resolve(k)]();
+  }
+  has(k) {
+    return !!this.types[this.resolve(k)];
+  }
+  cast(k, value) {
+    const resolved = this.resolve(k);
+    if (!this.has(k)) return null;
+    if (resolved === "boolean") {
+      if (["true", "1", "yes", true].indexOf(value) >= 0) return true;
+      return false;
+    }
+    if (resolved === "number") return parseFloat(value);
+    return value;
+  }
+  check(k, obj, opts) {
+    const resolved = this.resolve(k);
+    if (!this.has(k)) return false;
+    return this.types[resolved](obj, opts);
+  }
+  show() {
+    const obj = {};
+    for (const k in this.types) {
+      obj[k] = this.types[k]();
+    }
+    return obj;
+  }
+};
+var types_default = ZenTypes;
+
+// src/zen-error.ts
+var ZenError = class extends Error {
+  constructor(errors) {
+    if (errors.length === 1) {
+      super(errors[0].join(": "));
+    } else {
+      super(`Validation failed: ${errors.length} errors found`);
+    }
+    this.errors = errors;
+  }
+};
+var zen_error_default = ZenError;
+
+// src/index.ts
+var RX = {
+  FLAT_ARRAY: /(\[([^\[\]\{\}]*)\])/,
+  FLAT_OBJECT: /(\{([^\{\}\[\]]*)\})/,
+  MALFORMED: /[\[\]\{\}]/,
+  FLAT_SCALAR: /^[^\[\]\{\}]*$/,
+  OPTIONAL: /^[\?]/,
+  LOOKUP: /^[0-9]+$/,
+  DEFAULTS: /^\$([0-9]+)$/
+};
+var _flatten = (schema) => {
+  const lookups = [];
+  const default_strings = [];
+  let m;
+  while (m = schema.match(/"([^"]+)"/)) {
+    schema = schema.slice(0, m.index) + `$${default_strings.length}` + schema.slice(m.index + m[0].length);
+    default_strings.push(m[1]);
+  }
+  while (m = schema.match(/'([^']+)'/)) {
+    schema = schema.slice(0, m.index) + `$${default_strings.length}` + schema.slice(m.index + m[0].length);
+    default_strings.push(m[1]);
+  }
+  if (schema.match(/"/)) throw new Error("Missing closing quote");
+  schema = schema.replace(/\s/g, "");
+  function reduce(schema2) {
+    let m2;
+    let found = false;
+    while ((m2 = schema2.match(RX.FLAT_ARRAY)) || (m2 = schema2.match(RX.FLAT_OBJECT))) {
+      schema2 = schema2.slice(0, m2.index) + lookups.length + schema2.slice(m2.index + m2[0].length);
+      lookups.push(m2[0]);
+      found = true;
+    }
+    if (found) return reduce(schema2);
+    if (!found && schema2.match(RX.MALFORMED)) {
+      throw new Error("Schema error: probably invalid braces or brackets");
+    }
+    return schema2;
+  }
+  schema = reduce(schema);
+  return [schema, lookups, default_strings];
+};
+function splitOnce(str, delim) {
+  const parts = str.split(delim);
+  const first = parts.shift();
+  return [first, parts.join(delim)];
+}
+var typeShape = (schema) => {
+  let [sch, lookups, default_strings] = _flatten(schema);
+  function traverse(sch2) {
+    if (!sch2) return "";
+    let m;
+    if (sch2.match(RX.LOOKUP)) return traverse(lookups[Number(sch2)]);
+    if (m = sch2.match(RX.FLAT_ARRAY)) {
+      sch2 = m[2];
+      const schema_parts = sch2.split(",");
+      return schema_parts.length > 0 ? [traverse(schema_parts[0])] : [traverse("")];
+    }
+    if (m = sch2.match(RX.FLAT_OBJECT)) {
+      sch2 = m[2];
+      return sch2.split(",").reduce((acc, name) => {
+        let [k, v] = splitOnce(name, ":");
+        if (k.match(RX.DEFAULTS)) k = default_strings[Number(k.slice(1))];
+        acc[k] = traverse(v);
+        return acc;
+      }, {});
+    }
+    if (sch2.match(RX.FLAT_SCALAR)) {
+      let [type, def] = sch2.split(":");
+      if (!def) def = "";
+      if (def && def.match(RX.DEFAULTS)) def = default_strings[Number(def.substr(1))];
+      let optional = "";
+      if (type.match(RX.OPTIONAL)) {
+        optional = "?";
+        type = type.slice(1);
+      }
+      const type_lookup = types_default.ALIASES;
+      if (type_lookup[type]) type = type_lookup[type];
+      return [optional, type, def].join(":");
+    }
+    return "";
+  }
+  return traverse(sch);
+};
+var toSchema = (json) => {
+  function traverse(obj) {
+    const type = types_default.toSchema(obj);
+    if (type === "array") {
+      const arr = obj;
+      const sch = arr.length > 0 ? traverse(arr[0]) : "";
+      return `[${sch}]`;
+    }
+    if (type === "object") {
+      const objRecord = obj;
+      return "{" + Object.keys(objRecord).map((k) => {
+        return `${k}:${traverse(objRecord[k])}`;
+      }).join(",") + "}";
+    }
+    return type;
+  }
+  return traverse(json);
+};
+var shape = (json, schema, options = {}) => {
+  const types = new types_default(options);
+  options._optional = options._optional || false;
+  let lookups;
+  let default_strings;
+  [schema, lookups, default_strings] = _flatten(schema);
+  const getValue = (type, value, def) => {
+    let m;
+    if (def && (m = def.match(RX.DEFAULTS))) def = default_strings[Number(m[1])];
+    if (types.has(type)) {
+      return value && types.check(type, value) ? value : def !== void 0 ? types.cast(type, def) : types.sample(type);
+    }
+    return value || def || "Not defined!";
+  };
+  function traverse({ value, schema: schema2 }) {
+    if (!schema2) schema2 = "";
+    let m;
+    let optional = false;
+    if (schema2.match(RX.OPTIONAL)) {
+      schema2 = schema2.slice(1);
+      optional = true;
+    }
+    if (schema2.match(RX.LOOKUP)) return traverse({ value, schema: `${optional ? "?" : ""}${lookups[Number(schema2)]}` });
+    if ((value === null || value === void 0) && optional && !options._optional) return null;
+    if (schema2.match(RX.FLAT_SCALAR)) {
+      let type;
+      let def;
+      [type, def] = schema2.split(":");
+      return getValue(type, value, def);
+    } else if (m = schema2.match(RX.FLAT_ARRAY)) {
+      schema2 = m[2];
+      const schema_parts = schema2.split(",");
+      let arr = value;
+      if (!Array.isArray(value)) arr = schema_parts.map(() => null);
+      if (arr.length < schema_parts.length) {
+        arr = arr.concat(schema_parts.slice(arr.length).map(() => null));
+      }
+      return arr.map((v, i) => traverse({ value: v, schema: schema_parts[i % schema_parts.length] }));
+    } else if (m = schema2.match(RX.FLAT_OBJECT)) {
+      let obj = value;
+      if (typeof value !== "object" || Array.isArray(value)) {
+        obj = {};
+      }
+      schema2 = m[2];
+      if (schema2 === "") return obj;
+      let wildcard = false;
+      const shp = schema2.split(",").reduce((acc, name) => {
+        let [k, t, d] = name.split(":");
+        if (!t) t = "";
+        if (d) t += ":" + d;
+        if (k === "*") wildcard = t;
+        else acc[k] = traverse({ value: obj[k], schema: t });
+        return acc;
+      }, {});
+      if (wildcard !== false) {
+        for (const k in obj) if (shp[k] === void 0) shp[k] = traverse({ value: obj[k], schema: wildcard });
+      }
+      return shp;
+    }
+    return value;
+  }
+  const result = traverse({ value: json, schema });
+  return result;
+};
+var verify = (json, schema, options = {}) => {
+  const types = new types_default(options);
+  const errors = [];
+  const jsonPath = options._path || "json";
+  let lookups;
+  [schema, lookups] = _flatten(schema);
+  function validate({ path, value, schema: schema2, parent = null }) {
+    let m;
+    let optional = false;
+    if (schema2.match(RX.OPTIONAL)) {
+      schema2 = schema2.slice(1);
+      if (value === void 0 || value === null) return true;
+      optional = true;
+    }
+    if (schema2.match(RX.LOOKUP)) return validate({ path: `${path}`, value, schema: `${optional ? "?" : ""}${lookups[Number(schema2)]}`, parent });
+    if (schema2.match(RX.FLAT_SCALAR)) {
+      let def;
+      [schema2, def] = schema2.split(":");
+      if (value === void 0 || value === null) {
+        errors.push([path, "is required"]);
+        return false;
+      }
+      if (schema2 === "") return true;
+      if (!types.has(schema2)) throw new Error(`Schema error: Validator - ${schema2} - not found`);
+      else if (types.check(schema2, value, { path, json, parent })) return true;
+      else {
+        errors.push([path, "validation failed"]);
+        return false;
+      }
+    } else if (m = schema2.match(RX.FLAT_ARRAY)) {
+      if (!Array.isArray(value)) {
+        errors.push([path, "should be array"]);
+        return false;
+      }
+      schema2 = m[2];
+      const schema_parts = schema2.split(",");
+      for (const i in value) {
+        validate({ path: `${path}.${i}`, value: value[i], schema: schema_parts[Number(i) % schema_parts.length], parent: value });
+      }
+      return true;
+    } else if (m = schema2.match(RX.FLAT_OBJECT)) {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        errors.push([path, "should be object"]);
+        return false;
+      }
+      schema2 = m[2];
+      let wildcard = false;
+      if (schema2 !== "") {
+        const obj = value;
+        const keys = schema2.split(",").reduce((acc, name) => {
+          let [k, t] = name.split(":");
+          if (!t) t = "";
+          if (k === "*") wildcard = t;
+          else acc[k] = t;
+          return acc;
+        }, {});
+        if (wildcard !== false) {
+          for (const k in obj) if (keys[k] === void 0) keys[k] = wildcard;
+        }
+        for (const k in keys) validate({ path: `${path}.${k}`, value: obj[k], schema: keys[k], parent: value });
+      }
+      return true;
+    }
+    return true;
+  }
+  validate({ path: jsonPath, value: json, schema });
+  if (errors.length > 0) throw new zen_error_default(errors);
+  return true;
+};
+var check = (json, schema, options) => {
+  try {
+    verify(json, schema, options);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && error.message.match(/^Schema error/)) throw error;
+    return false;
+  }
+};
+var extendTypes = (types) => {
+  types_default.extend(types);
+};
+module.exports = { verify, check, shape, toSchema, _flatten, typeShape, extendTypes };
+export {
+  _flatten,
+  check,
+  extendTypes,
+  shape,
+  toSchema,
+  typeShape,
+  verify
+};

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "@sleekcms/json-zen",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Easify verify and shape JSON objects using a simplified alternative JSON schema",
   "main": "./lib/index.js",
+  "module": "./lib/esm/index.js",
   "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/index.js"
+    }
+  },
   "scripts": {
     "clean": "rimraf lib",
     "test": "npm run cover",
@@ -11,7 +19,9 @@
     "test:watch": "npm test -- --watch",
     "cover": "nyc npm run test:only",
     "lint": "eslint src test --ext .ts",
-    "build": "tsc",
+    "build:cjs": "tsc",
+    "build:esm": "esbuild src/index.ts --bundle --format=esm --platform=browser --outfile=lib/esm/index.js",
+    "build": "npm run build:cjs && npm run build:esm",
     "prepublish": "npm run clean && npm run test && npm run build"
   },
   "files": [
@@ -45,6 +55,7 @@
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",
     "chai": "^4.3.4",
+    "esbuild": "^0.27.5",
     "eslint": "^8.3.0",
     "mocha": "^9.1.3",
     "nyc": "^15.1.0",