@atscript/typescript 0.0.29 → 0.0.31

package/dist/utils.mjs

@@ -0,0 +1,546 @@
+
+//#region packages/typescript/src/validator.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+const regexCache = new Map();
+var Validator = class {
+	isLimitExceeded() {
+		if (this.stackErrors.length > 0) return this.stackErrors[this.stackErrors.length - 1].length >= this.opts.errorLimit;
+		return this.errors.length >= this.opts.errorLimit;
+	}
+	push(name) {
+		this.stackPath.push(name);
+		this.stackErrors.push([]);
+	}
+	pop(saveErrors) {
+		this.stackPath.pop();
+		const popped = this.stackErrors.pop();
+		if (saveErrors && popped?.length) popped.forEach((error) => {
+			this.error(error.message, error.path, error.details);
+		});
+		return popped;
+	}
+	clear() {
+		this.stackErrors[this.stackErrors.length - 1] = [];
+	}
+	error(message, path, details) {
+		const errors = this.stackErrors[this.stackErrors.length - 1] || this.errors;
+		const error = {
+			path: path || this.path,
+			message
+		};
+		if (details?.length) error.details = details;
+		errors.push(error);
+	}
+	throw() {
+		throw new ValidatorError(this.errors);
+	}
+	validate(value, safe) {
+		this.push("");
+		this.errors = [];
+		this.stackErrors = [];
+		const passed = this.validateSafe(this.def, value);
+		this.pop(!passed);
+		if (!passed) {
+			if (safe) return false;
+			this.throw();
+		}
+		return true;
+	}
+	validateSafe(def, value) {
+		if (this.isLimitExceeded()) return false;
+		if (!isAnnotatedType(def)) throw new Error("Can not validate not-annotated type");
+		if (typeof this.opts.replace === "function") def = this.opts.replace(def, this.path);
+		if (def.optional && value === undefined) return true;
+		for (const plugin of this.opts.plugins) {
+			const result = plugin(this, def, value);
+			if (result === false || result === true) return result;
+		}
+		return this.validateAnnotatedType(def, value);
+	}
+	get path() {
+		return this.stackPath.slice(1).join(".");
+	}
+	validateAnnotatedType(def, value) {
+		switch (def.type.kind) {
+			case "object": return this.validateObject(def, value);
+			case "union": return this.validateUnion(def, value);
+			case "intersection": return this.validateIntersection(def, value);
+			case "tuple": return this.validateTuple(def, value);
+			case "array": return this.validateArray(def, value);
+			case "": return this.validatePrimitive(def, value);
+			default: throw new Error(`Unknown type "${def.type.kind}"`);
+		}
+	}
+	validateUnion(def, value) {
+		let i = 0;
+		const popped = [];
+		for (const item of def.type.items) {
+			this.push(`[${item.type.kind || item.type.designType}(${i})]`);
+			if (this.validateSafe(item, value)) {
+				this.pop(false);
+				return true;
+			}
+			const errors = this.pop(false);
+			if (errors) popped.push(...errors);
+			i++;
+		}
+		this.clear();
+		const expected = def.type.items.map((item, i$1) => `[${item.type.kind || item.type.designType}(${i$1})]`).join(", ");
+		this.error(`Value does not match any of the allowed types: ${expected}`, undefined, popped);
+		return false;
+	}
+	validateIntersection(def, value) {
+		for (const item of def.type.items) if (!this.validateSafe(item, value)) return false;
+		return true;
+	}
+	validateTuple(def, value) {
+		if (!Array.isArray(value) || value.length !== def.type.items.length) {
+			this.error(`Expected array of length ${def.type.items.length}`);
+			return false;
+		}
+		let i = 0;
+		for (const item of def.type.items) {
+			this.push(`[${i}]`);
+			if (!this.validateSafe(item, value[i])) {
+				this.pop(true);
+				return false;
+			}
+			this.pop(false);
+			i++;
+		}
+		return true;
+	}
+	validateArray(def, value) {
+		if (!Array.isArray(value)) {
+			this.error("Expected array");
+			return false;
+		}
+		const minLength = def.metadata.get("expect.minLength");
+		if (typeof minLength === "number" && value.length < minLength) {
+			this.error(`Expected minimum length of ${minLength} items, got ${value.length} items`);
+			return false;
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (typeof maxLength === "number" && value.length > maxLength) {
+			this.error(`Expected maximum length of ${maxLength} items, got ${value.length} items`);
+			return false;
+		}
+		let i = 0;
+		let passed = true;
+		for (const item of value) {
+			this.push(`[${i}]`);
+			if (!this.validateSafe(def.type.of, item)) {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			} else this.pop(false);
+			i++;
+		}
+		return passed;
+	}
+	validateObject(def, value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) {
+			this.error("Expected object");
+			return false;
+		}
+		let passed = true;
+		const valueKeys = new Set(Object.keys(value));
+		const typeKeys = new Set();
+		const skipList = new Set();
+		if (this.opts.skipList) {
+			const path = this.stackPath.length > 1 ? `${this.path}.` : "";
+			this.opts.skipList.forEach((item) => {
+				if (item.startsWith(path)) {
+					const key = item.slice(path.length);
+					skipList.add(key);
+					valueKeys.delete(key);
+				}
+			});
+		}
+		let partialFunctionMatched = false;
+		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.path);
+		for (const [key, item] of def.type.props.entries()) {
+			if (skipList.has(key)) continue;
+			typeKeys.add(key);
+			if (value[key] === undefined) {
+				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
+			}
+			this.push(key);
+			if (this.validateSafe(item, value[key])) this.pop(false);
+else {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			}
+		}
+		for (const key of valueKeys)
+ /** matched patterns for unknown keys */ if (!typeKeys.has(key)) {
+			const matched = [];
+			for (const { pattern, def: propDef } of def.type.propsPatterns) if (pattern.test(key)) matched.push({
+				pattern,
+				def: propDef
+			});
+			if (matched.length) {
+				let keyPassed = false;
+				for (const { def: def$1 } of matched) if (this.validateSafe(def$1, value[key])) {
+					this.pop(false);
+					keyPassed = true;
+					break;
+				}
+				if (!keyPassed) {
+					this.push(key);
+					this.validateSafe(matched[0].def, value[key]);
+					this.pop(true);
+					passed = false;
+					if (this.isLimitExceeded()) return false;
+				}
+			} else if (this.opts.unknwonProps !== "ignore") {
+				if (this.opts.unknwonProps === "error") {
+					this.push(key);
+					this.error(`Unexpected property`);
+					this.pop(true);
+					if (this.isLimitExceeded()) return false;
+					passed = false;
+				} else if (this.opts.unknwonProps === "strip") delete value[key];
+			}
+		}
+		return passed;
+	}
+	validatePrimitive(def, value) {
+		if (typeof def.type.value !== "undefined") {
+			if (value !== def.type.value) {
+				this.error(`Expected ${def.type.value}, got ${value}`);
+				return false;
+			}
+			return true;
+		}
+		const typeOfValue = Array.isArray(value) ? "array" : typeof value;
+		switch (def.type.designType) {
+			case "never":
+				this.error(`This type is impossible, must be an internal problem`);
+				return false;
+			case "any": return true;
+			case "string":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateString(def, value);
+			case "number":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateNumber(def, value);
+			case "boolean":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			case "undefined":
+				if (value !== undefined) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			case "null":
+				if (value !== null) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			default: throw new Error(`Unknown type "${def.type.designType}"`);
+		}
+	}
+	validateString(def, value) {
+		const minLength = def.metadata.get("expect.minLength");
+		if (typeof minLength === "number" && value.length < minLength) {
+			this.error(`Expected minimum length of ${minLength} characters, got ${value.length} characters`);
+			return false;
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (typeof maxLength === "number" && value.length > maxLength) {
+			this.error(`Expected maximum length of ${maxLength} characters, got ${value.length} characters`);
+			return false;
+		}
+		const patterns = def.metadata.get("expect.pattern");
+		for (const { pattern, flags, message } of patterns || []) {
+			if (!pattern) continue;
+			const cacheKey = `${pattern}//${flags || ""}`;
+			let regex = regexCache.get(cacheKey);
+			if (!regex) {
+				regex = new RegExp(pattern, flags);
+				regexCache.set(cacheKey, regex);
+			}
+			if (!regex.test(value)) {
+				this.error(message || `Value is expected to match pattern "${pattern}"`);
+				return false;
+			}
+		}
+		return true;
+	}
+	validateNumber(def, value) {
+		const int = def.metadata.get("expect.int");
+		if (typeof int === "boolean" && int && value % 1 !== 0) {
+			this.error(`Expected integer, got ${value}`);
+			return false;
+		}
+		const min = def.metadata.get("expect.min");
+		if (typeof min === "number" && value < min) {
+			this.error(`Expected minimum ${min}, got ${value}`);
+			return false;
+		}
+		const max = def.metadata.get("expect.max");
+		if (typeof max === "number" && value > max) {
+			this.error(`Expected maximum ${max}, got ${value}`);
+			return false;
+		}
+		return true;
+	}
+	constructor(def, opts) {
+		_define_property(this, "def", void 0);
+		_define_property(this, "opts", void 0);
+		_define_property(this, "errors", void 0);
+		_define_property(this, "stackErrors", void 0);
+		_define_property(this, "stackPath", void 0);
+		this.def = def;
+		this.errors = [];
+		this.stackErrors = [];
+		this.stackPath = [];
+		this.opts = {
+			partial: false,
+			unknwonProps: "error",
+			errorLimit: 10,
+			...opts,
+			plugins: opts?.plugins || []
+		};
+	}
+};
+var ValidatorError = class extends Error {
+	constructor(errors) {
+		super(`${errors[0].path ? errors[0].path + ": " : ""}${errors[0].message}`), _define_property(this, "errors", void 0), _define_property(this, "name", void 0), this.errors = errors, this.name = "Validation Error";
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/annotated-type.ts
+function isAnnotatedType(type) {
+	return type && type.__is_atscript_annotated_type;
+}
+function defineAnnotatedType(_kind, base) {
+	const kind = _kind || "";
+	const type = base?.type || {};
+	type.kind = kind;
+	if ([
+		"union",
+		"intersection",
+		"tuple"
+	].includes(kind)) type.items = [];
+	if (kind === "object") {
+		type.props = new Map();
+		type.propsPatterns = [];
+	}
+	type.tags = new Set();
+	const metadata = base?.metadata || new Map();
+	if (base) Object.assign(base, {
+		__is_atscript_annotated_type: true,
+		metadata,
+		type,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	});
+else base = {
+		__is_atscript_annotated_type: true,
+		metadata,
+		type,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	};
+	const handle = {
+		$type: base,
+		$def: type,
+		$metadata: metadata,
+		_existingObject: undefined,
+		tags(...tags) {
+			for (const tag of tags) this.$def.tags.add(tag);
+			return this;
+		},
+		designType(value) {
+			this.$def.designType = value;
+			return this;
+		},
+		value(value) {
+			this.$def.value = value;
+			return this;
+		},
+		of(value) {
+			this.$def.of = value;
+			return this;
+		},
+		item(value) {
+			this.$def.items.push(value);
+			return this;
+		},
+		prop(name, value) {
+			this.$def.props.set(name, value);
+			return this;
+		},
+		propPattern(pattern, def) {
+			this.$def.propsPatterns.push({
+				pattern,
+				def
+			});
+			return this;
+		},
+		optional(value = true) {
+			this.$type.optional = value;
+			return this;
+		},
+		copyMetadata(fromMetadata, ignore) {
+			for (const [key, value] of fromMetadata.entries()) if (!ignore || !ignore.has(key)) this.$metadata.set(key, value);
+			return this;
+		},
+		refTo(type$1, chain) {
+			let newBase = type$1;
+			const typeName = type$1.name || "Unknown";
+			if (isAnnotatedType(newBase)) {
+				let keys = "";
+				for (const c of chain || []) {
+					keys += `["${c}"]`;
+					if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
+else throw new Error(`Can't find prop ${typeName}${keys}`);
+				}
+				if (!newBase && keys) throw new Error(`Can't find prop ${typeName}${keys}`);
+else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
+				this.$type = {
+					__is_atscript_annotated_type: true,
+					type: newBase.type,
+					metadata,
+					validator(opts) {
+						return new Validator(this, opts);
+					}
+				};
+			} else throw new Error(`${type$1} is not annotated type`);
+			return this;
+		},
+		annotate(key, value, asArray) {
+			if (asArray) if (this.$metadata.has(key)) {
+				const a = this.$metadata.get(key);
+				if (Array.isArray(a)) a.push(value);
+else this.$metadata.set(key, [a, value]);
+			} else this.$metadata.set(key, [value]);
+else this.$metadata.set(key, value);
+			return this;
+		}
+	};
+	return handle;
+}
+function isAnnotatedTypeOfPrimitive(t) {
+	if (["array", "object"].includes(t.type.kind)) return false;
+	if (!t.type.kind) return true;
+	if ([
+		"union",
+		"tuple",
+		"intersection"
+	].includes(t.type.kind)) {
+		for (const item of t.type.items) if (!isAnnotatedTypeOfPrimitive(item)) return false;
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region packages/typescript/src/json-schema.ts
+function buildJsonSchema(type) {
+	const build = (def) => {
+		const t = def.type;
+		const meta = def.metadata;
+		switch (t.kind) {
+			case "object": {
+				const obj = t;
+				const properties = {};
+				const required = [];
+				for (const [key, val] of obj.props.entries()) {
+					properties[key] = build(val);
+					if (!val.optional) required.push(key);
+				}
+				const schema = {
+					type: "object",
+					properties
+				};
+				if (required.length) schema.required = required;
+				return schema;
+			}
+			case "array": {
+				const arr = t;
+				const schema = {
+					type: "array",
+					items: build(arr.of)
+				};
+				const minLength = meta.get("expect.minLength");
+				if (typeof minLength === "number") schema.minItems = minLength;
+				const maxLength = meta.get("expect.maxLength");
+				if (typeof maxLength === "number") schema.maxItems = maxLength;
+				return schema;
+			}
+			case "union": {
+				const grp = t;
+				return { anyOf: grp.items.map(build) };
+			}
+			case "intersection": {
+				const grp = t;
+				return { allOf: grp.items.map(build) };
+			}
+			case "tuple": {
+				const grp = t;
+				return {
+					type: "array",
+					items: grp.items.map(build),
+					additionalItems: false
+				};
+			}
+			case "": {
+				const fin = t;
+				const schema = {};
+				if (fin.value !== undefined) schema.const = fin.value;
+				if (fin.designType && fin.designType !== "any") {
+					schema.type = fin.designType === "undefined" ? "null" : fin.designType;
+					if (schema.type === "number" && meta.get("expect.int")) schema.type = "integer";
+				}
+				if (schema.type === "string") {
+					const minLength = meta.get("expect.minLength");
+					if (typeof minLength === "number") schema.minLength = minLength;
+					const maxLength = meta.get("expect.maxLength");
+					if (typeof maxLength === "number") schema.maxLength = maxLength;
+					const patterns = meta.get("expect.pattern");
+					if (patterns?.length) if (patterns.length === 1) schema.pattern = patterns[0].pattern;
+else schema.allOf = (schema.allOf || []).concat(patterns.map((p) => ({ pattern: p.pattern })));
+				}
+				if (schema.type === "number" || schema.type === "integer") {
+					const min = meta.get("expect.min");
+					if (typeof min === "number") schema.minimum = min;
+					const max = meta.get("expect.max");
+					if (typeof max === "number") schema.maximum = max;
+				}
+				return schema;
+			}
+			default: return {};
+		}
+	};
+	return build(type);
+}
+
+//#endregion
+export { Validator, ValidatorError, buildJsonSchema, defineAnnotatedType, isAnnotatedType, isAnnotatedTypeOfPrimitive };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/typescript",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "Atscript: typescript-gen support.",
   "type": "module",
   "main": "dist/index.mjs",
@@ -9,10 +9,27 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.mjs",
+      "require": "./dist/utils.cjs",
+      "default": "./dist/utils.mjs"
     },
     "./package.json": "./package.json"
   },
+  "typesVersions": {
+    "*": {
+      "utils": [
+        "dist/utils.d.ts"
+      ],
+      "": [
+        "dist/index.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist",
     "cli.cjs"
@@ -22,6 +39,12 @@
   },
   "build": [
     {},
+    {
+      "entries": [
+        "src/utils.ts"
+      ],
+      "dts": true
+    },
     {
       "format": "cjs",
       "entries": [
@@ -47,7 +70,7 @@
   "homepage": "https://github.com/moostjs/atscript/tree/main/packages/typescript#readme",
   "license": "ISC",
   "peerDependencies": {
-    "@atscript/core": "^0.0.29"
+    "@atscript/core": "^0.0.31"
   },
   "dependencies": {
     "@moostjs/event-cli": "^0.5.32",