@sleekcms/json-zen 1.0.0

package/src/lib.ts

@@ -0,0 +1,31 @@
+export function isArray(value: unknown): value is unknown[] {
+  return Array.isArray(value);
+}
+
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function isString(value: unknown): value is string {
+  return typeof value === 'string' || value instanceof String;
+}
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === 'number' || value instanceof Number;
+}
+
+export function isBoolean(value: unknown): value is boolean {
+  return typeof value === 'boolean' || value instanceof Boolean;
+}
+
+export function isInteger(value: unknown): value is number {
+  return Number.isInteger(value);
+}
+
+export function isFunction(value: unknown): value is Function {
+  return typeof value === 'function';
+}
+
+export function isRegExp(value: unknown): value is RegExp {
+  return value instanceof RegExp;
+}

package/src/types.ts

@@ -0,0 +1,115 @@
+import { isArray, isObject, isString, isNumber, isBoolean, isRegExp } from "./lib";
+
+export interface CheckOptions {
+  path?: string;
+  json?: unknown;
+  parent?: unknown;
+}
+
+export type TypeValidatorFunction = (value?: unknown, opts?: CheckOptions) => boolean | unknown;
+
+export interface TypesMap {
+  [key: string]: TypeValidatorFunction;
+}
+
+class ZenTypes {
+  types: TypesMap;
+
+  static ALIASES: Record<string, string> = {
+    "s": "string",
+    "n": "number",
+    "b": "boolean",
+  };
+
+  static TYPES: TypesMap = {
+    "string": (v?: unknown) => v !== undefined ? isString(v) : "",
+    "number": (v?: unknown) => v !== undefined ? isNumber(v) : 0,
+    "boolean": (v?: unknown) => v !== undefined ? isBoolean(v) : true,
+    "null": (v?: unknown) => v !== undefined ? v === null : null,
+  };
+
+  constructor(types?: Record<string, unknown>) {
+    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: unknown): TypeValidatorFunction {
+    if (isArray(fn)) {
+      const lookup = fn as string[];
+      return (v?: unknown): boolean | string => {
+        if (v !== undefined) return !isString(v) || lookup.indexOf(v as string) >= 0;
+        else return lookup[(Math.random() * lookup.length) | 0];
+      };
+    } else if (isRegExp(fn)) {
+      const regex = fn as RegExp;
+      return (v?: unknown): boolean | string => {
+        if (v !== undefined) return !isString(v) || regex.test(v as string);
+        else return regex.source.replace(/\\(.)/g, "$1");
+      };
+    }
+    return fn as TypeValidatorFunction;
+  }
+
+  static extend(obj: Record<string, unknown>): void {
+    for (const k in obj) {
+      this.TYPES[k] = this._toType(obj[k]);
+    }
+  }
+
+  static toSchema(obj: unknown): string {
+    if (obj === null) return "?";
+    if (obj === undefined) 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: string): string {
+    return ZenTypes.ALIASES[k] ?? k;
+  }
+
+  sample(k: string): unknown {
+    if (!this.has(k)) return null;
+    return this.types[this.resolve(k)]();
+  }
+
+  has(k: string): boolean {
+    return !!this.types[this.resolve(k)];
+  }
+
+  cast(k: string, value: unknown): unknown {
+    const resolved = this.resolve(k);
+    if (!this.has(k)) return null;
+    if (resolved === "boolean") {
+      if (["true", "1", "yes", true].indexOf(value as string | boolean) >= 0) return true;
+      return false;
+    }
+    if (resolved === "number") return parseFloat(value as string);
+    return value;
+  }
+
+  check(k: string, obj: unknown, opts?: CheckOptions): boolean {
+    const resolved = this.resolve(k);
+    if (!this.has(k)) return false;
+    return this.types[resolved](obj, opts) as boolean;
+  }
+
+  show(): Record<string, unknown> {
+    const obj: Record<string, unknown> = {};
+    for (const k in this.types) {
+      obj[k] = this.types[k]();
+    }
+    return obj;
+  }
+}
+
+export default ZenTypes;

package/src/zen-error.ts

@@ -0,0 +1,16 @@
+export type ValidationError = [string, string];
+
+export class ZenError extends Error {
+  errors: ValidationError[];
+
+  constructor(errors: ValidationError[]) {
+    if (errors.length === 1) {
+      super(errors[0].join(": "));
+    } else {
+      super(`Validation failed: ${errors.length} errors found`);
+    }
+    this.errors = errors;
+  }
+}
+
+export default ZenError;