@threadlabs/looma 0.19.1 → 0.20.0

package/vue/chunks/props.js

@@ -0,0 +1,477 @@
+//#region .build/vue/props.ts
+var CSS_NAMED_COLOR_SET = /* @__PURE__ */ new Set([
+	"accentcolor",
+	"accentcolortext",
+	"activetext",
+	"aliceblue",
+	"antiquewhite",
+	"aqua",
+	"aquamarine",
+	"azure",
+	"beige",
+	"bisque",
+	"black",
+	"blanchedalmond",
+	"blue",
+	"blueviolet",
+	"brown",
+	"burlywood",
+	"buttonborder",
+	"buttonface",
+	"buttontext",
+	"cadetblue",
+	"canvas",
+	"canvastext",
+	"chartreuse",
+	"chocolate",
+	"coral",
+	"cornflowerblue",
+	"cornsilk",
+	"crimson",
+	"currentcolor",
+	"cyan",
+	"darkblue",
+	"darkcyan",
+	"darkgoldenrod",
+	"darkgray",
+	"darkgreen",
+	"darkgrey",
+	"darkkhaki",
+	"darkmagenta",
+	"darkolivegreen",
+	"darkorange",
+	"darkorchid",
+	"darkred",
+	"darksalmon",
+	"darkseagreen",
+	"darkslateblue",
+	"darkslategray",
+	"darkslategrey",
+	"darkturquoise",
+	"darkviolet",
+	"deeppink",
+	"deepskyblue",
+	"dimgray",
+	"dimgrey",
+	"dodgerblue",
+	"field",
+	"fieldtext",
+	"firebrick",
+	"floralwhite",
+	"forestgreen",
+	"fuchsia",
+	"gainsboro",
+	"ghostwhite",
+	"gold",
+	"goldenrod",
+	"gray",
+	"graytext",
+	"green",
+	"greenyellow",
+	"grey",
+	"highlight",
+	"highlighttext",
+	"honeydew",
+	"hotpink",
+	"indianred",
+	"indigo",
+	"ivory",
+	"khaki",
+	"lavender",
+	"lavenderblush",
+	"lawngreen",
+	"lemonchiffon",
+	"lightblue",
+	"lightcoral",
+	"lightcyan",
+	"lightgoldenrodyellow",
+	"lightgray",
+	"lightgreen",
+	"lightgrey",
+	"lightpink",
+	"lightsalmon",
+	"lightseagreen",
+	"lightskyblue",
+	"lightslategray",
+	"lightslategrey",
+	"lightsteelblue",
+	"lightyellow",
+	"lime",
+	"limegreen",
+	"linen",
+	"linktext",
+	"magenta",
+	"mark",
+	"marktext",
+	"maroon",
+	"mediumaquamarine",
+	"mediumblue",
+	"mediumorchid",
+	"mediumpurple",
+	"mediumseagreen",
+	"mediumslateblue",
+	"mediumspringgreen",
+	"mediumturquoise",
+	"mediumvioletred",
+	"midnightblue",
+	"mintcream",
+	"mistyrose",
+	"moccasin",
+	"navajowhite",
+	"navy",
+	"oldlace",
+	"olive",
+	"olivedrab",
+	"orange",
+	"orangered",
+	"orchid",
+	"palegoldenrod",
+	"palegreen",
+	"paleturquoise",
+	"palevioletred",
+	"papayawhip",
+	"peachpuff",
+	"peru",
+	"pink",
+	"plum",
+	"powderblue",
+	"purple",
+	"rebeccapurple",
+	"red",
+	"rosybrown",
+	"royalblue",
+	"saddlebrown",
+	"salmon",
+	"sandybrown",
+	"seagreen",
+	"seashell",
+	"selecteditem",
+	"selecteditemtext",
+	"sienna",
+	"silver",
+	"skyblue",
+	"slateblue",
+	"slategray",
+	"slategrey",
+	"snow",
+	"springgreen",
+	"steelblue",
+	"tan",
+	"teal",
+	"thistle",
+	"tomato",
+	"transparent",
+	"turquoise",
+	"violet",
+	"visitedtext",
+	"wheat",
+	"white",
+	"whitesmoke",
+	"yellow",
+	"yellowgreen"
+]);
+var HTML_EMAIL_PATTERN = /^[a-zA-Z0-9.!#$%&'*+/?=^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+var HtmlDiagnosticError = class extends Error {
+	diagnostic;
+	constructor(code, message) {
+		super(code + ": " + message);
+		this.name = "HtmlDiagnosticError";
+		this.diagnostic = Object.freeze({
+			code,
+			message
+		});
+	}
+};
+function issue(path, message) {
+	return {
+		ok: false,
+		issues: [path + ": " + message]
+	};
+}
+function pathAt(path, key) {
+	if (typeof key === "number") return path + "[" + key + "]";
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? path + "." + key : path + "[" + JSON.stringify(key) + "]";
+}
+function plainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function structured(value) {
+	return value;
+}
+function trusted(value, name) {
+	if (typeof value !== "object" || value === null) return false;
+	if (value.kind === name && "value" in value) return true;
+	const expected = name === "trusted-html" ? "TrustedHTML" : "TrustedScript";
+	return value.constructor?.name === expected || Object.prototype.toString.call(value) === "[object " + expected + "]";
+}
+function validDate(value) {
+	const match = /^([0-9]{4,})-([0-9]{2})-([0-9]{2})$/.exec(value);
+	if (match === null || match[1] === "0000") return false;
+	const year = Number(match[1]);
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(year, Number(match[2]) - 1, Number(match[3]));
+	return date.getUTCFullYear() === year && date.getUTCMonth() === Number(match[2]) - 1 && date.getUTCDate() === Number(match[3]);
+}
+function validTime(value) {
+	const match = /^([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\.([0-9]{1,3}))?)?$/.exec(value);
+	return match !== null && Number(match[1]) < 24 && Number(match[2]) < 60 && Number(match[3] ?? 0) < 60;
+}
+function validFunctionalColor(value) {
+	const match = /^(rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color)\((.*)\)$/i.exec(value);
+	if (match === null) return false;
+	const body = match[2].trim();
+	const parts = body.replaceAll(",", " ").replaceAll("/", " ").split(/\s+/);
+	if (match[1].toLowerCase() === "color" && !/^(?:srgb|srgb-linear|display-p3|a98-rgb|prophoto-rgb|rec2020|xyz|xyz-d50|xyz-d65)$/.test(parts.shift() ?? "")) return false;
+	if (parts.length < 3 || parts.length > 4) return false;
+	if (parts.length === 4 && !body.includes("/") && !body.includes(",")) return false;
+	return parts.every((part) => part === "none" || /^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:%|deg|rad|grad|turn)?$/.test(part));
+}
+function validFormat(value, name) {
+	switch (name) {
+		case "keyword": return /^[A-Za-z0-9_-]+$/.test(value);
+		case "url": try {
+			return new URL(value).protocol !== "";
+		} catch {
+			return false;
+		}
+		case "email": return HTML_EMAIL_PATTERN.test(value);
+		case "date": return validDate(value);
+		case "month": return /^(?!0000)[0-9]{4,}-(?:0[1-9]|1[0-2])$/.test(value);
+		case "week": {
+			const match = /^([0-9]{4,})-W([0-9]{2})$/.exec(value);
+			if (match === null || match[1] === "0000") return false;
+			const year = Number(match[1]);
+			const week = Number(match[2]);
+			const jan1 = /* @__PURE__ */ new Date(0);
+			jan1.setUTCFullYear(year, 0, 1);
+			const jan1Day = jan1.getUTCDay();
+			const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+			return week >= 1 && (week < 53 || week === 53 && (jan1Day === 4 || jan1Day === 3 && leap));
+		}
+		case "time": return validTime(value);
+		case "datetime-local": {
+			const match = /^([0-9]{4,}-[0-9]{2}-[0-9]{2})[T ](.+)$/.exec(value);
+			return match !== null && validDate(match[1]) && validTime(match[2]);
+		}
+		case "datetime": {
+			const match = /^([0-9]{4,}-[0-9]{2}-[0-9]{2})T([0-9]{2}:[0-9]{2}(?::[0-9]{2}(?:\.[0-9]{1,3})?)?)(Z|[+-](?:0[0-9]|1[0-9]|2[0-3]):[0-5][0-9])$/.exec(value);
+			return match !== null && validDate(match[1]) && validTime(match[2]);
+		}
+		case "color-hex": return /^#[0-9a-fA-F]{3}(?:[0-9a-fA-F]{1}|[0-9a-fA-F]{3}(?:[0-9a-fA-F]{2})?)?$/.test(value);
+		case "color": return validFormat(value, "color-hex") || CSS_NAMED_COLOR_SET.has(value.toLowerCase()) || validFunctionalColor(value);
+		case "length": return /^-?(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+)(?:px|em|rem|vw|vh|vmin|vmax|ch|ex|cm|mm|in|pt|pc|q)$/.test(value) || value === "0";
+		case "percentage": return /^-?(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+)%$/.test(value);
+		case "duration": return /^-?(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+)(?:ms|s)$/.test(value);
+		default: return false;
+	}
+}
+function typeName(node) {
+	switch (node.kind) {
+		case "terminal": return node.name;
+		case "separated-list": return "keyword" + (node.separator === "space" ? "+" : "#");
+		case "keyword": return /^[A-Za-z_][A-Za-z0-9_-]*$/.test(node.value) && ![
+			"string",
+			"boolean",
+			"number",
+			"integer",
+			"null",
+			"absent",
+			"trusted-html",
+			"trusted-script",
+			"function",
+			"unknown",
+			"list",
+			"record",
+			"object"
+		].includes(node.value) ? node.value : JSON.stringify(node.value);
+		case "union": return node.members.map(typeName).join(" | ");
+		case "constrained": return typeName(node.base) + " with values " + node.values.map(String).join(", ");
+		case "list": return "list(" + typeName(node.item) + ")";
+		case "record": return "record(" + typeName(node.value) + ")";
+		case "object": return "object({ " + [...node.fields.map((field) => field.name + (field.optional ? "?" : "") + ": " + typeName(field.type)), ...node.open ? ["..."] : []].join(", ") + " })";
+	}
+}
+function parse(value, node, path) {
+	switch (node.kind) {
+		case "terminal":
+			switch (node.name) {
+				case "string": return typeof value === "string" ? {
+					ok: true,
+					value
+				} : issue(path, "Must be a string.");
+				case "keyword":
+				case "url":
+				case "email":
+				case "date":
+				case "month":
+				case "week":
+				case "time":
+				case "datetime-local":
+				case "datetime":
+				case "color":
+				case "color-hex":
+				case "length":
+				case "percentage":
+				case "duration": return typeof value === "string" && validFormat(value, node.name) ? {
+					ok: true,
+					value
+				} : issue(path, "Must be a valid " + node.name + " value.");
+				case "boolean": return typeof value === "boolean" ? {
+					ok: true,
+					value
+				} : issue(path, "Must be true or false.");
+				case "number":
+				case "integer": {
+					const number = typeof value === "number" ? value : NaN;
+					if (!Number.isFinite(number)) return issue(path, node.name === "integer" ? "Must be an integer." : "Must be a finite number.");
+					if (node.name === "integer" && !Number.isInteger(number)) return issue(path, "Must be an integer.");
+					return {
+						ok: true,
+						value: number
+					};
+				}
+				case "null": return value === null ? {
+					ok: true,
+					value
+				} : issue(path, "Must be null.");
+				case "absent": return value === void 0 ? {
+					ok: true,
+					value
+				} : issue(path, "Must be absent.");
+				case "trusted-html":
+				case "trusted-script": return trusted(value, node.name) ? {
+					ok: true,
+					value
+				} : issue(path, "Must be a " + (node.name === "trusted-html" ? "TrustedHTML" : "TrustedScript") + " value.");
+				case "function": return typeof value === "function" ? {
+					ok: true,
+					value
+				} : issue(path, "Must be a function supplied through a property.");
+				case "unknown": return {
+					ok: true,
+					value
+				};
+			}
+			return issue(path, "Unknown declared type.");
+		case "separated-list": return Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && /^[A-Za-z0-9_-]+$/.test(item)) ? {
+			ok: true,
+			value
+		} : issue(path, "Must be a nonempty keyword list.");
+		case "keyword": return value === node.value ? {
+			ok: true,
+			value
+		} : issue(path, "Must be " + JSON.stringify(node.value) + ".");
+		case "union":
+			for (const member of node.members) {
+				const result = parse(value, member, path);
+				if (result.ok) return result;
+			}
+			return issue(path, "Must match " + typeName(node) + ".");
+		case "constrained": {
+			const parsed = parse(value, node.base, path);
+			return parsed.ok && node.values.some((choice) => choice === parsed.value) ? parsed : issue(path, "Must be one of " + node.values.map(String).join(", ") + ".");
+		}
+		case "list": {
+			const input = structured(value);
+			if (!Array.isArray(input)) return issue(path, "Must be a list.");
+			const output = [];
+			const issues = [];
+			input.forEach((item, index) => {
+				const result = parse(item, node.item, pathAt(path, index));
+				if (result.ok) output.push(result.value);
+				else issues.push(...result.issues);
+			});
+			return issues.length === 0 ? {
+				ok: true,
+				value: output
+			} : {
+				ok: false,
+				issues
+			};
+		}
+		case "record": {
+			const input = structured(value);
+			if (!plainObject(input)) return issue(path, "Must be a string-keyed record.");
+			const output = {};
+			const issues = [];
+			for (const [key, item] of Object.entries(input)) {
+				const result = parse(item, node.value, pathAt(path, key));
+				if (result.ok) output[key] = result.value;
+				else issues.push(...result.issues);
+			}
+			return issues.length === 0 ? {
+				ok: true,
+				value: output
+			} : {
+				ok: false,
+				issues
+			};
+		}
+		case "object": {
+			const input = structured(value);
+			if (!plainObject(input)) return issue(path, "Must be an object.");
+			const output = {};
+			const issues = [];
+			const fields = new Map(node.fields.map((field) => [field.name, field]));
+			for (const field of node.fields) {
+				if (!(field.name in input)) {
+					if (!field.optional) issues.push(pathAt(path, field.name) + ": Required field is absent.");
+					continue;
+				}
+				const result = parse(input[field.name], field.type, pathAt(path, field.name));
+				if (result.ok) output[field.name] = result.value;
+				else issues.push(...result.issues);
+			}
+			for (const [key, item] of Object.entries(input)) {
+				if (fields.has(key)) continue;
+				if (node.open) output[key] = item;
+				else issues.push(pathAt(path, key) + ": Field is not declared by this closed object type.");
+			}
+			return issues.length === 0 ? {
+				ok: true,
+				value: output
+			} : {
+				ok: false,
+				issues
+			};
+		}
+	}
+}
+/** Match HTML Next's typed invocation boundary before Vue renders or a controller reads a prop. */
+function selectedPropNode(selector, options) {
+	if (selector === null || selector === void 0) return {
+		kind: "terminal",
+		name: "null"
+	};
+	const option = options.find((candidate) => candidate.value === selector);
+	if (option === void 0) throw new HtmlDiagnosticError("HR002", "A selecting prop has no matching type option.");
+	return option.type;
+}
+function checkedProp(value, type, required, name, pattern, values) {
+	if (value === void 0) {
+		if (required) throw new HtmlDiagnosticError("HC020", "Required prop `" + name + "` was not provided.");
+		return null;
+	}
+	if (value === null) {
+		if (required) throw new HtmlDiagnosticError("HC021", "A required prop cannot be null.");
+		return null;
+	}
+	if (required && value === "") throw new HtmlDiagnosticError("HR002", "A required prop cannot be empty.");
+	const result = parse(value, type, "$");
+	if (!result.ok) throw new HtmlDiagnosticError("HR002", "A prop invocation value does not satisfy its declared type. " + result.issues.join("; "));
+	if (values !== void 0 && !values.some((choice) => choice === result.value)) throw new HtmlDiagnosticError("HR002", "A prop invocation value is not among its permitted values.");
+	if (pattern !== void 0 && value !== "") {
+		let expression;
+		try {
+			expression = new RegExp("^(?:" + pattern + ")$", "v");
+		} catch {
+			expression = new RegExp("^(?:" + pattern + ")$", "u");
+		}
+		if (typeof value !== "string" || !expression.test(value)) throw new HtmlDiagnosticError("HR002", "A prop invocation value does not match its pattern.");
+	}
+	return result.value;
+}
+//#endregion
+export { selectedPropNode as n, checkedProp as t };