@atscript/typescript 0.1.2 → 0.1.4

package/dist/utils.cjs

@@ -1,5 +1,23 @@
 "use strict";
 
+//#region packages/typescript/src/traverse.ts
+function forAnnotatedType(def, handlers) {
+	switch (def.type.kind) {
+		case "": {
+			const typed = def;
+			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
+			return handlers.final(typed);
+		}
+		case "object": return handlers.object(def);
+		case "array": return handlers.array(def);
+		case "union": return handlers.union(def);
+		case "intersection": return handlers.intersection(def);
+		case "tuple": return handlers.tuple(def);
+		default: throw new Error(`Unknown type kind "${def.type.kind}"`);
+	}
+}
+
+//#endregion
 //#region packages/typescript/src/validator.ts
 function _define_property(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
@@ -44,7 +62,17 @@ var Validator = class {
 	throw() {
 		throw new ValidatorError(this.errors);
 	}
-	validate(value, safe) {
+	/**
+	* Validates a value against the type definition.
+	*
+	* Acts as a TypeScript type guard — when it returns `true`, the value
+	* is narrowed to `DataType`.
+	*
+	* @param value - The value to validate.
+	* @param safe - If `true`, returns `false` on failure instead of throwing.
+	* @returns `true` if the value matches the type definition.
+	* @throws {ValidatorError} When validation fails and `safe` is not `true`.
+	*/ validate(value, safe) {
 		this.push("");
 		this.errors = [];
 		this.stackErrors = [];
@@ -71,15 +99,15 @@ var Validator = class {
 		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}"`);
-		}
+		return forAnnotatedType(def, {
+			final: (d) => this.validatePrimitive(d, value),
+			phantom: () => true,
+			object: (d) => this.validateObject(d, value),
+			array: (d) => this.validateArray(d, value),
+			union: (d) => this.validateUnion(d, value),
+			intersection: (d) => this.validateIntersection(d, value),
+			tuple: (d) => this.validateTuple(d, value)
+		});
 	}
 	validateUnion(def, value) {
 		let i = 0;
@@ -170,7 +198,7 @@ var Validator = class {
 		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;
+			if (skipList.has(key) || isPhantomType(item)) continue;
 			typeKeys.add(key);
 			if (value[key] === undefined) {
 				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
@@ -311,7 +339,7 @@ else {
 	constructor(def, opts) {
 		_define_property(this, "def", void 0);
 		_define_property(this, "opts", void 0);
-		_define_property(this, "errors", void 0);
+		/** Validation errors collected during the last {@link validate} call. */ _define_property(this, "errors", void 0);
 		_define_property(this, "stackErrors", void 0);
 		_define_property(this, "stackPath", void 0);
 		this.def = def;
@@ -452,6 +480,9 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 	};
 	return handle;
 }
+function isPhantomType(def) {
+	return def.type.kind === "" && def.type.designType === "phantom";
+}
 function isAnnotatedTypeOfPrimitive(t) {
 	if (["array", "object"].includes(t.type.kind)) return false;
 	if (!t.type.kind) return true;
@@ -470,14 +501,16 @@ function isAnnotatedTypeOfPrimitive(t) {
 //#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;
+		return forAnnotatedType(def, {
+			phantom() {
+				return {};
+			},
+			object(d) {
 				const properties = {};
 				const required = [];
-				for (const [key, val] of obj.props.entries()) {
+				for (const [key, val] of d.type.props.entries()) {
+					if (isPhantomType(val)) continue;
 					properties[key] = build(val);
 					if (!val.optional) required.push(key);
 				}
@@ -487,41 +520,36 @@ function buildJsonSchema(type) {
 				};
 				if (required.length) schema.required = required;
 				return schema;
-			}
-			case "array": {
-				const arr = t;
+			},
+			array(d) {
 				const schema = {
 					type: "array",
-					items: build(arr.of)
+					items: build(d.type.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;
+			},
+			union(d) {
+				return { anyOf: d.type.items.map(build) };
+			},
+			intersection(d) {
+				return { allOf: d.type.items.map(build) };
+			},
+			tuple(d) {
 				return {
 					type: "array",
-					items: grp.items.map(build),
+					items: d.type.items.map(build),
 					additionalItems: false
 				};
-			}
-			case "": {
-				const fin = t;
+			},
+			final(d) {
 				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 (d.type.value !== undefined) schema.const = d.type.value;
+				if (d.type.designType && d.type.designType !== "any") {
+					schema.type = d.type.designType === "undefined" ? "null" : d.type.designType;
 					if (schema.type === "number" && meta.get("expect.int")) schema.type = "integer";
 				}
 				if (schema.type === "string") {
@@ -541,17 +569,277 @@ else schema.allOf = (schema.allOf || []).concat(patterns.map((p) => ({ pattern:
 				}
 				return schema;
 			}
-			default: return {};
-		}
+		});
 	};
 	return build(type);
 }
+function fromJsonSchema(schema) {
+	const convert = (s) => {
+		if (!s || Object.keys(s).length === 0) return defineAnnotatedType().designType("any").$type;
+		if (s.$ref) throw new Error("$ref is not supported by fromJsonSchema. Dereference the schema first.");
+		if ("const" in s) {
+			const val = s.const;
+			const dt = val === null ? "null" : typeof val;
+			return defineAnnotatedType().designType(dt).value(val).$type;
+		}
+		if (s.enum) {
+			const handle = defineAnnotatedType("union");
+			for (const val of s.enum) {
+				const dt = val === null ? "null" : typeof val;
+				handle.item(defineAnnotatedType().designType(dt).value(val).$type);
+			}
+			return handle.$type;
+		}
+		if (s.anyOf) {
+			const handle = defineAnnotatedType("union");
+			for (const item of s.anyOf) handle.item(convert(item));
+			return handle.$type;
+		}
+		if (s.oneOf) {
+			const handle = defineAnnotatedType("union");
+			for (const item of s.oneOf) handle.item(convert(item));
+			return handle.$type;
+		}
+		if (s.allOf && !s.type) {
+			const handle = defineAnnotatedType("intersection");
+			for (const item of s.allOf) handle.item(convert(item));
+			return handle.$type;
+		}
+		if (Array.isArray(s.type)) {
+			const handle = defineAnnotatedType("union");
+			for (const t of s.type) handle.item(convert({
+				...s,
+				type: t
+			}));
+			return handle.$type;
+		}
+		if (s.type === "object") {
+			const handle = defineAnnotatedType("object");
+			const required = new Set(s.required || []);
+			if (s.properties) for (const [key, propSchema] of Object.entries(s.properties)) {
+				const propType = convert(propSchema);
+				if (!required.has(key)) propType.optional = true;
+				handle.prop(key, propType);
+			}
+			return handle.$type;
+		}
+		if (s.type === "array") {
+			if (Array.isArray(s.items)) {
+				const handle$1 = defineAnnotatedType("tuple");
+				for (const item of s.items) handle$1.item(convert(item));
+				return handle$1.$type;
+			}
+			const itemType = s.items ? convert(s.items) : defineAnnotatedType().designType("any").$type;
+			const handle = defineAnnotatedType("array").of(itemType);
+			if (typeof s.minItems === "number") handle.annotate("expect.minLength", s.minItems);
+			if (typeof s.maxItems === "number") handle.annotate("expect.maxLength", s.maxItems);
+			return handle.$type;
+		}
+		if (s.type === "string") {
+			const handle = defineAnnotatedType().designType("string").tags("string");
+			if (typeof s.minLength === "number") handle.annotate("expect.minLength", s.minLength);
+			if (typeof s.maxLength === "number") handle.annotate("expect.maxLength", s.maxLength);
+			if (s.pattern) handle.annotate("expect.pattern", { pattern: s.pattern }, true);
+			if (s.allOf) {
+				for (const item of s.allOf) if (item.pattern) handle.annotate("expect.pattern", { pattern: item.pattern }, true);
+			}
+			return handle.$type;
+		}
+		if (s.type === "integer") {
+			const handle = defineAnnotatedType().designType("number").tags("number");
+			handle.annotate("expect.int", true);
+			if (typeof s.minimum === "number") handle.annotate("expect.min", s.minimum);
+			if (typeof s.maximum === "number") handle.annotate("expect.max", s.maximum);
+			return handle.$type;
+		}
+		if (s.type === "number") {
+			const handle = defineAnnotatedType().designType("number").tags("number");
+			if (typeof s.minimum === "number") handle.annotate("expect.min", s.minimum);
+			if (typeof s.maximum === "number") handle.annotate("expect.max", s.maximum);
+			return handle.$type;
+		}
+		if (s.type === "boolean") return defineAnnotatedType().designType("boolean").tags("boolean").$type;
+		if (s.type === "null") return defineAnnotatedType().designType("null").tags("null").$type;
+		return defineAnnotatedType().designType("any").$type;
+	};
+	return convert(schema);
+}
+
+//#endregion
+//#region packages/typescript/src/serialize.ts
+const SERIALIZE_VERSION = 1;
+function serializeAnnotatedType(type, options) {
+	const result = serializeNode(type, [], options);
+	result.$v = SERIALIZE_VERSION;
+	return result;
+}
+function serializeNode(def, path, options) {
+	const result = {
+		type: serializeTypeDef(def, path, options),
+		metadata: serializeMetadata(def.metadata, path, def.type.kind, options)
+	};
+	if (def.optional) result.optional = true;
+	return result;
+}
+function serializeTypeDef(def, path, options) {
+	return forAnnotatedType(def, {
+		phantom(d) {
+			return {
+				kind: "",
+				designType: d.type.designType,
+				tags: Array.from(d.type.tags)
+			};
+		},
+		final(d) {
+			const result = {
+				kind: "",
+				designType: d.type.designType,
+				tags: Array.from(d.type.tags)
+			};
+			if (d.type.value !== undefined) result.value = d.type.value;
+			return result;
+		},
+		object(d) {
+			const props = {};
+			for (const [key, val] of d.type.props.entries()) {
+				if (isPhantomType(val)) continue;
+				props[key] = serializeNode(val, [...path, key], options);
+			}
+			const propsPatterns = d.type.propsPatterns.map((pp) => ({
+				pattern: {
+					source: pp.pattern.source,
+					flags: pp.pattern.flags
+				},
+				def: serializeNode(pp.def, path, options)
+			}));
+			return {
+				kind: "object",
+				props,
+				propsPatterns,
+				tags: Array.from(d.type.tags)
+			};
+		},
+		array(d) {
+			return {
+				kind: "array",
+				of: serializeNode(d.type.of, path, options),
+				tags: Array.from(d.type.tags)
+			};
+		},
+		union(d) {
+			return {
+				kind: "union",
+				items: d.type.items.map((item) => serializeNode(item, path, options)),
+				tags: Array.from(d.type.tags)
+			};
+		},
+		intersection(d) {
+			return {
+				kind: "intersection",
+				items: d.type.items.map((item) => serializeNode(item, path, options)),
+				tags: Array.from(d.type.tags)
+			};
+		},
+		tuple(d) {
+			return {
+				kind: "tuple",
+				items: d.type.items.map((item) => serializeNode(item, path, options)),
+				tags: Array.from(d.type.tags)
+			};
+		}
+	});
+}
+function serializeMetadata(metadata, path, kind, options) {
+	const result = {};
+	const ignoreSet = options?.ignoreAnnotations ? new Set(options.ignoreAnnotations) : undefined;
+	for (const [key, value] of metadata.entries()) {
+		if (ignoreSet?.has(key)) continue;
+		if (options?.processAnnotation) {
+			const processed = options.processAnnotation({
+				key,
+				value,
+				path,
+				kind
+			});
+			if (processed === undefined || processed === null) continue;
+			result[processed.key] = processed.value;
+			continue;
+		}
+		result[key] = value;
+	}
+	return result;
+}
+function deserializeAnnotatedType(data) {
+	if (data.$v !== SERIALIZE_VERSION) throw new Error(`Unsupported serialized type version: ${data.$v} (expected ${SERIALIZE_VERSION})`);
+	return deserializeNode(data);
+}
+function deserializeNode(data) {
+	const metadata = new Map(Object.entries(data.metadata));
+	const type = deserializeTypeDef(data.type);
+	const result = {
+		__is_atscript_annotated_type: true,
+		type,
+		metadata,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	};
+	if (data.optional) result.optional = true;
+	return result;
+}
+function deserializeTypeDef(t) {
+	const tags = new Set(t.tags);
+	switch (t.kind) {
+		case "": {
+			const result = {
+				kind: "",
+				designType: t.designType,
+				tags
+			};
+			if (t.value !== undefined) result.value = t.value;
+			return result;
+		}
+		case "object": {
+			const props = new Map();
+			for (const [key, val] of Object.entries(t.props)) props.set(key, deserializeNode(val));
+			const propsPatterns = t.propsPatterns.map((pp) => ({
+				pattern: new RegExp(pp.pattern.source, pp.pattern.flags),
+				def: deserializeNode(pp.def)
+			}));
+			return {
+				kind: "object",
+				props,
+				propsPatterns,
+				tags
+			};
+		}
+		case "array": return {
+			kind: "array",
+			of: deserializeNode(t.of),
+			tags
+		};
+		case "union":
+		case "intersection":
+		case "tuple": return {
+			kind: t.kind,
+			items: t.items.map((item) => deserializeNode(item)),
+			tags
+		};
+		default: throw new Error(`Unknown serialized type kind "${t.kind}"`);
+	}
+}
 
 //#endregion
+exports.SERIALIZE_VERSION = SERIALIZE_VERSION
 exports.Validator = Validator
 exports.ValidatorError = ValidatorError
 exports.annotate = annotate
 exports.buildJsonSchema = buildJsonSchema
 exports.defineAnnotatedType = defineAnnotatedType
+exports.deserializeAnnotatedType = deserializeAnnotatedType
+exports.forAnnotatedType = forAnnotatedType
+exports.fromJsonSchema = fromJsonSchema
 exports.isAnnotatedType = isAnnotatedType
-exports.isAnnotatedTypeOfPrimitive = isAnnotatedTypeOfPrimitive
+exports.isAnnotatedTypeOfPrimitive = isAnnotatedTypeOfPrimitive
+exports.isPhantomType = isPhantomType
+exports.serializeAnnotatedType = serializeAnnotatedType