@jolibox/implement 1.1.4-beta.4

package/src/common/api-factory/validator/validate.ts

@@ -0,0 +1,639 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+type Constructor<T> = new (...args: any[]) => T;
+
+export type Primitive = string | number | symbol | boolean | undefined | null;
+
+export let collectError = false;
+
+export function setCollect(flag: boolean) {
+  collectError = flag;
+}
+function deepClone<T>(obj: T): T {
+  if (obj === null || typeof obj !== 'object') {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item)) as T;
+  }
+
+  return Object.keys(obj as object).reduce((acc, key) => {
+    acc[key as keyof T] = deepClone((obj as any)[key]);
+    return acc;
+  }, {} as T);
+}
+
+export abstract class Validator<T = unknown> {
+  path?: string;
+  errors: string[] = [];
+
+  abstract validate(x: unknown): x is T;
+
+  protected fail(message: string): false;
+  protected fail(options: { expect: string; actual: unknown }): false;
+  protected fail(options: { expect: string; actual: unknown } | string) {
+    if (collectError) {
+      if (typeof options === 'string') {
+        this.errors.push(options);
+      } else {
+        let message = `${this.path} should be ${options.expect}`;
+        if (this._optional && options.expect !== 'undefined') {
+          message += ' or undefined, ';
+        } else {
+          message += ', ';
+        }
+        message += `but got ${echo(options.actual)}`;
+        this.errors.push(message);
+      }
+    }
+    return false;
+  }
+
+  hasFallback = false;
+  _fallback?: T;
+  fallback(v: T) {
+    this.hasFallback = true;
+    this._fallback = v;
+    return this;
+  }
+
+  get fallbackValue(): T {
+    return deepClone(this._fallback as T);
+  }
+
+  hasDefault = false;
+  protected _default?: T;
+  default(v: T) {
+    this.hasDefault = true;
+    this._default = v;
+    return this;
+  }
+
+  get defaultValue() {
+    if (typeof this._default === 'function') {
+      return this._default;
+    }
+    return deepClone(this._default as T);
+  }
+
+  _optional = false;
+  optional(): Validator<T | undefined> {
+    this._optional = true;
+    return this as Validator<T | undefined>;
+  }
+}
+
+export function isNumber(x: unknown): x is number {
+  return typeof x === 'number';
+}
+
+export function echo(x: unknown) {
+  const s = getType(x);
+  switch (s) {
+    case 'string':
+      return `"${x}"`;
+    case 'number':
+    case 'boolean':
+    case 'null':
+    case 'undefined':
+      return String(x);
+    default:
+      return `a(n) ${s}`;
+  }
+}
+
+export function getType(x: unknown) {
+  if (typeof x === 'function') return 'function';
+
+  const type = Object.prototype.toString.call(x).slice(8).slice(0, -1);
+
+  return type.toLowerCase();
+}
+
+export class $number extends Validator<number> {
+  private _min?: number;
+  private _max?: number;
+  private _isInt?: boolean;
+  private _greater?: number;
+
+  validate(x: unknown): x is number {
+    if (this._optional && x === undefined) return true;
+
+    if (!isNumber(x)) {
+      return this.fail({ expect: 'number', actual: x });
+    }
+
+    if (isNumber(this._min) && x < this._min) {
+      return this.fail(`the value of ${this.path} should be greater than or equal to ${this._min}`);
+    }
+
+    if (isNumber(this._max) && x > this._max) {
+      return this.fail(`the value of ${this.path} should be less than or equal to ${this._max}`);
+    }
+
+    if (isNumber(this._greater) && x <= this._greater) {
+      return this.fail(`the value of ${this.path} should be greater than ${this._greater}`);
+    }
+
+    if (this._isInt && x !== Math.floor(x)) {
+      return this.fail(`the value of ${this.path} should be integer but got ${x}`);
+    }
+    return true;
+  }
+
+  min(v: number) {
+    this._min = v;
+    return this;
+  }
+
+  max(v: number) {
+    this._max = v;
+    return this;
+  }
+
+  isInt(v: boolean) {
+    this._isInt = v;
+    return this;
+  }
+
+  greater(v: number) {
+    this._greater = v;
+    return this;
+  }
+}
+
+export class $boolean extends Validator<boolean> {
+  validate(x: unknown): x is boolean {
+    if (this._optional && x === undefined) return true;
+
+    if (typeof x !== 'boolean') {
+      return this.fail({ expect: 'boolean', actual: x });
+    }
+
+    return true;
+  }
+}
+
+export class $string extends Validator<string> {
+  private _minLength?: number;
+  private _maxLength?: number;
+  private _pattern?: string | RegExp;
+
+  validate(x: unknown): x is string {
+    if (this._optional && x === undefined) return true;
+
+    if (typeof x !== 'string') {
+      return this.fail({ expect: 'string', actual: x });
+    }
+
+    if (isNumber(this._maxLength) && x.length > this._maxLength) {
+      return this.fail(`the length of ${this.path} should be less than or equal to ${this._maxLength}`);
+    }
+
+    if (isNumber(this._minLength) && x.length < this._minLength) {
+      return this.fail(`the length of ${this.path} should be greater than or equal to ${this._minLength}`);
+    }
+
+    if (typeof this._pattern === 'string') {
+      const reg = new RegExp(this._pattern);
+      if (!reg.test(x)) {
+        return this.fail(`${this.path} should match pattern "${this._pattern}"`);
+      }
+    } else if (this._pattern) {
+      if (!this._pattern.test(x)) {
+        return this.fail(`${this.path} should match pattern "${this._pattern.toString()}"`);
+      }
+    }
+
+    return true;
+  }
+
+  minLength(len: number) {
+    this._minLength = len;
+    return this;
+  }
+
+  maxLength(len: number) {
+    this._maxLength = len;
+    return this;
+  }
+
+  pattern(patten: string | RegExp) {
+    this._pattern = patten;
+    return this;
+  }
+}
+
+export class $symbol extends Validator<symbol> {
+  validate(x: unknown): x is symbol {
+    if (this._optional && x === undefined) return true;
+
+    if (typeof x !== 'symbol') {
+      return this.fail({ expect: 'symbol', actual: x });
+    }
+
+    return true;
+  }
+}
+
+export class $any<T = any> extends Validator<T> {
+  // eslint-disable-next-line class-methods-use-this
+  validate(x: unknown): x is T {
+    return true;
+  }
+}
+
+export class $undefined extends Validator<undefined> {
+  validate(x: unknown): x is undefined {
+    if (x !== undefined) {
+      return this.fail({ expect: 'undefined', actual: x });
+    }
+    return true;
+  }
+}
+
+export class $null extends Validator<null> {
+  validate(x: unknown): x is null {
+    if (this._optional && x === undefined) return true;
+
+    if (x !== null) {
+      return this.fail({ expect: 'null', actual: x });
+    }
+    return true;
+  }
+}
+
+export class $function extends Validator<(...args: any[]) => any> {
+  validate(x: unknown): x is (...args: any[]) => any {
+    if (this._optional && x === undefined) return true;
+
+    if (typeof x !== 'function') {
+      return this.fail({ expect: 'function', actual: x });
+    }
+    return true;
+  }
+}
+
+export class $enum<T> extends Validator<T> {
+  private readonly _items: (string | number | undefined)[];
+  constructor(..._items: (string | number | undefined)[]) {
+    super();
+    this._items = _items;
+  }
+
+  validate(x: unknown): x is T {
+    if (this._optional && x === undefined) return true;
+
+    if (!this._items.includes(x as any)) {
+      const enums = this._items.map((i) => JSON.stringify(i)).join(', ');
+
+      return this.fail(`expect ${this.path} to be one of ${enums}, but got ${echo(x)}`);
+    }
+
+    return true;
+  }
+}
+
+export class $array<T extends unknown> extends Validator<T[]> {
+  private _minItems?: number;
+  private _maxItems?: number;
+  private _uniqueItems?: boolean;
+  private _length?: number;
+
+  constructor(private readonly _item?: Validator) {
+    super();
+  }
+
+  validate(x: unknown): x is T[] {
+    if (this._optional && x === undefined) return true;
+
+    if (!Array.isArray(x)) {
+      return this.fail({ expect: 'array', actual: x });
+    }
+
+    if (isNumber(this._minItems) && x.length < this._minItems) {
+      return this.fail(`the length of ${this.path} should be greater than or equal to ${this._minItems}`);
+    }
+
+    if (isNumber(this._maxItems) && x.length > this._maxItems) {
+      return this.fail(`the length of ${this.path} should be less than or equal to ${this._maxItems}`);
+    }
+
+    if (isNumber(this._length) && x.length !== this._length) {
+      return this.fail(`the length of ${this.path} should be equal to ${this._length}`);
+    }
+
+    const validator = this._item;
+
+    if (!validator) return true;
+
+    let result = true;
+
+    x.forEach((item, index) => {
+      validator.path = `${this.path}[${index}]`;
+      validator.errors = this.errors;
+
+      if (item === undefined && validator.hasDefault) {
+        x[index] = validator.defaultValue;
+        return;
+      }
+      if (!validator.validate(item)) {
+        if (validator.hasFallback) {
+          x[index] = validator.fallbackValue;
+        } else {
+          result = false;
+        }
+      }
+    });
+
+    if (this._uniqueItems) {
+      const map = new Map();
+      for (let i in x) {
+        if (map.has(x[i])) {
+          result = this.fail(
+            `${this.path} should NOT have duplicate items (${this.path}[${map.get(x[i])}] and ${
+              this.path
+            }[${i}] are identical)`
+          );
+        } else {
+          map.set(x[i], i);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  minItems(len: number) {
+    this._minItems = len;
+    return this;
+  }
+
+  maxItems(len: number) {
+    this._maxItems = len;
+    return this;
+  }
+
+  uniqueItems() {
+    this._uniqueItems = true;
+    return this;
+  }
+
+  length(len: number) {
+    this._length = len;
+    return this;
+  }
+}
+
+export class $record<T> extends Validator<Record<string, T>> {
+  constructor(private readonly _value: Validator) {
+    super();
+  }
+
+  validate(x: unknown): x is Record<string, T> {
+    if (this._optional && x === undefined) return true;
+
+    const type = getType(x);
+
+    if (type !== 'object') {
+      return this.fail({ expect: 'object', actual: x });
+    }
+
+    const values = x as Record<string, unknown>;
+
+    const validator = this._value;
+    validator.errors = this.errors;
+
+    let result = true;
+
+    // eslint-disable-next-line guard-for-in
+    for (const k in values) {
+      const value = values[k];
+
+      if (/^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/.test(k)) {
+        validator.path = `${this.path}.${k}`;
+      } else {
+        validator.path = `${this.path}["${k}"]`;
+      }
+
+      if (value === undefined && validator._optional) {
+        continue;
+      }
+
+      if (value === undefined && validator.hasDefault) {
+        values[k] = validator.defaultValue;
+        continue;
+      }
+
+      if (!validator.validate(value)) {
+        if (validator.hasFallback) {
+          values[k] = validator.fallbackValue;
+        } else {
+          result = false;
+        }
+      }
+    }
+
+    return result;
+  }
+}
+
+export class $object<T extends object> extends Validator<T> {
+  constructor(private readonly _object: Record<string, Validator> = {}) {
+    super();
+  }
+
+  validate(x: unknown): x is T {
+    if (this._optional && x === undefined) return true;
+
+    if (getType(x) !== 'object') {
+      return this.fail({ expect: 'object', actual: x });
+    }
+
+    const values = x as Record<string, unknown>;
+
+    let result = true;
+
+    // eslint-disable-next-line guard-for-in
+    for (const k in this._object) {
+      const value = values[k];
+      const validator = this._object[k];
+
+      validator.errors = this.errors;
+
+      if (/^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/.test(k)) {
+        validator.path = `${this.path}.${k}`;
+      } else {
+        validator.path = `${this.path}["${k}"]`;
+      }
+
+      if (validator._optional && value === undefined) {
+        continue;
+      }
+
+      if (value === undefined && validator.hasDefault) {
+        values[k] = validator.defaultValue;
+        continue;
+      }
+
+      if (!validator.validate(value)) {
+        if (validator.hasFallback) {
+          values[k] = validator.fallbackValue;
+        } else {
+          result = false;
+        }
+      }
+    }
+
+    return result;
+  }
+}
+
+export class $literal<T extends Primitive> extends Validator<T> {
+  constructor(private readonly value: T) {
+    super();
+  }
+
+  validate(x: unknown): x is T {
+    if (x === undefined && this._optional) return true;
+
+    if (x !== this.value) {
+      return this.fail({ expect: echo(this.value), actual: x });
+    }
+    return true;
+  }
+}
+
+export class $or<T> extends Validator<T> {
+  private readonly _items: Validator[];
+  constructor(..._items: Validator[]) {
+    super();
+    this._items = _items;
+  }
+
+  validate(x: unknown): x is T {
+    if (x === undefined && this._optional) return true;
+
+    const orErrors: string[] = [];
+
+    let result = false;
+    const itemLength = this._items.length;
+    for (let i = 0; i < itemLength; i++) {
+      const validator = this._items[i];
+      validator.errors = [];
+      validator.path = this.path;
+      if (!validator.validate(x)) {
+        orErrors.push(validator.errors.join('; '));
+      } else if (!result) {
+        result = true;
+        break;
+      }
+    }
+
+    if (!result) {
+      const grouped = orErrors.join('\nor ');
+      this.errors.push(grouped);
+    }
+    return result;
+  }
+}
+
+export class $tuple<T extends unknown[]> extends Validator<T> {
+  private readonly _items: Validator[];
+  private readonly _minItems: number;
+
+  constructor(..._items: Validator[]) {
+    super();
+    this._items = _items;
+
+    let optionalCount = 0;
+    let i = _items.length - 1;
+    for (; i >= 0; i--) {
+      const validator = _items[i];
+      if (validator._optional || validator.hasDefault) {
+        optionalCount += 1;
+      } else {
+        break;
+      }
+    }
+    this._minItems = _items.length - optionalCount;
+  }
+
+  validate(x: unknown): x is T {
+    if (x === undefined && this._optional) return true;
+
+    if (!Array.isArray(x)) {
+      return this.fail({ expect: 'array', actual: x });
+    }
+
+    if (x.length < this._minItems) {
+      return this.fail(`the length of ${this.path} should be greater than or equal to ${this._minItems}`);
+    }
+
+    let result = true;
+
+    this._items.forEach((validator, index) => {
+      validator.path = `${this.path}[${index}]`;
+      validator.errors = this.errors;
+
+      const item = x[index];
+
+      if (item === undefined && validator.hasDefault) {
+        x[index] = validator.defaultValue;
+        return;
+      }
+
+      if (!validator.validate(x[index])) {
+        if (validator.hasFallback) {
+          x[index] = validator._fallback;
+        } else {
+          result = false;
+        }
+      }
+    });
+
+    return result;
+  }
+}
+
+export class $arraybuffer extends Validator<ArrayBuffer> {
+  validate(x: unknown): x is ArrayBuffer {
+    if (x === undefined && this._optional) return true;
+
+    if (x instanceof ArrayBuffer) {
+      return true;
+    }
+
+    return this.fail({ expect: 'arraybuffer', actual: x });
+  }
+}
+
+export type TypedArray =
+  | Uint8Array
+  | Int8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Int16Array
+  | Uint32Array
+  | Int32Array
+  | Float32Array
+  | Float64Array;
+
+export class $typedarray<T extends TypedArray> extends Validator<T> {
+  private readonly _ctor: Constructor<T>;
+
+  constructor(ctor: Constructor<T>) {
+    super();
+    this._ctor = ctor;
+  }
+
+  validate(x: unknown): x is T {
+    if (x === undefined && this._optional) return true;
+
+    if (x instanceof this._ctor) {
+      return true;
+    }
+
+    return this.fail({ expect: `typedarray of ${this._ctor.name}`, actual: x });
+  }
+}

package/src/common/can-i-use.ts

@@ -0,0 +1,19 @@
+import { CanIUseInfo, canIUseConfig, logger } from '@jolibox/common';
+
+export function registerCanIUseFactory(platform: keyof typeof canIUseConfig.config) {
+  let configMap = canIUseConfig.config[platform];
+  if (!configMap) {
+    configMap = {};
+    canIUseConfig.config[platform] = configMap;
+  }
+
+  return (name: string, config: CanIUseInfo): void => {
+    if (configMap![name]) {
+      logger.warn(`[can i use] ${name} already registered`);
+      return;
+    }
+    configMap![name] = {
+      ...config
+    };
+  };
+}