halfcode-compiler.xnl 0.2.1 → 0.2.2

package/dist/src-BlKlpg0J.js

@@ -1,180 +0,0 @@
-import { n as wordToString, t as parseXnl } from "./dist-Bkv7YeVi.js";
-import { copyFile, lstat, mkdir, readdir } from "node:fs/promises";
-import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
-//#region ../resource-mapping/src/index.ts
-function parseResourceMappings(source, uri = "vfs://./resource-mappings.xnl") {
-	let root;
-	try {
-		const document = parseXnl(source);
-		if (document.warnings?.length || document.nodes.length !== 1 || !isDataElement(document.nodes[0])) throw new Error("expected exactly one ResourceMappings data root without warnings");
-		root = document.nodes[0];
-	} catch (error) {
-		throw new Error(`Invalid ResourceMappings at ${uri}: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (root.tag !== "ResourceMappings") throw new Error(`Invalid ResourceMappings at ${uri}: root must be ResourceMappings`);
-	const referenceTargets = /* @__PURE__ */ new Map();
-	for (const entry of bodyElements(extension(root, "ReferenceTargets"), "ReferenceTarget")) {
-		const kind = requiredXnlProperty(entry, "kind", uri);
-		if (referenceTargets.has(kind)) throw new Error(`Invalid ResourceMappings at ${uri}: duplicate ReferenceTarget kind ${kind}`);
-		referenceTargets.set(kind, normalizeOutputDirectory(requiredXnlProperty(entry, "target", uri), uri));
-	}
-	const callable = extension(root, "CallableArtifacts");
-	const callableArtifactsTarget = normalizeOutputDirectory(callable ? requiredXnlProperty(callable, "target", uri) : "functions/", uri);
-	const sources = bodyElements(extension(root, "SourceRoots"), "SourceRoot").map((entry) => {
-		const id = wordToString(entry.id);
-		if (!id || !/^[A-Z][A-Za-z0-9]*$/.test(id)) throw new Error(`Invalid ResourceMappings at ${uri}: SourceRoot #id must be a PascalCase segment`);
-		const operations = (entry.body ?? []).filter(isDataElement).filter((operation) => operation.tag === "CopyDirectory" || operation.tag === "CopyFile").map((operation) => ({
-			kind: operation.tag,
-			from: normalizeRelativePath(requiredXnlProperty(operation, "from", uri), uri, "from"),
-			to: normalizeRelativePath(requiredXnlProperty(operation, "to", uri), uri, "to")
-		}));
-		return {
-			id,
-			sourceRoot: requiredXnlProperty(entry, "sourceRoot", uri),
-			operations
-		};
-	});
-	if (new Set(sources.map((item) => item.id)).size !== sources.length) throw new Error(`Invalid ResourceMappings at ${uri}: SourceRoot ids must be unique`);
-	return {
-		referenceTargets,
-		callableArtifactsTarget,
-		sources,
-		source: { uri }
-	};
-}
-function extension(node, name) {
-	const child = node.extend?.children[name];
-	return child?.kind === "DataElement" ? child : void 0;
-}
-function bodyElements(node, tag) {
-	return (node?.body ?? []).filter(isDataElement).filter((entry) => entry.tag === tag);
-}
-function requiredXnlProperty(node, name, uri) {
-	const value = node.attributes?.[name];
-	if (typeof value !== "string" || !value.trim()) throw new Error(`Invalid ResourceMappings at ${uri}: <${node.tag}> requires ${name}`);
-	return value;
-}
-function isDataElement(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && "kind" in value && value.kind === "DataElement";
-}
-async function planResourceMappings(mappings, options) {
-	const roots = asRootMap(options.moduleRoots);
-	const claims = [];
-	const entries = [];
-	const reserved = (options.reservedTargetPaths ?? []).map((path) => normalizeRelativePath(path, mappings.source.uri, "to"));
-	for (const mapping of mappings.sources) {
-		const sourceRootPath = resolveSourceRoot(mapping.sourceRoot, roots, options.defaultSourceRoot, mappings.source.uri);
-		await assertDirectory(sourceRootPath, mappings.source.uri, mapping.sourceRoot);
-		for (const operation of mapping.operations) {
-			for (const prior of claims) if (pathsOverlap(prior.target, operation.to)) throw new Error(`ResourceMappings target collision between ${prior.mappingId}:${prior.from} -> ${prior.target} and ${mapping.id}:${operation.from} -> ${operation.to}`);
-			claims.push({
-				target: operation.to,
-				mappingId: mapping.id,
-				from: operation.from
-			});
-			const sourcePath = safeResolve(sourceRootPath, operation.from, mappings.source.uri);
-			if (operation.kind === "CopyFile") {
-				await assertFile(sourcePath, mappings.source.uri, operation.from);
-				assertNotReserved(operation.to, reserved, mappings.source.uri);
-				entries.push({
-					sourcePath,
-					targetRelativePath: operation.to,
-					mappingId: mapping.id
-				});
-				continue;
-			}
-			await assertDirectory(sourcePath, mappings.source.uri, operation.from);
-			for (const filePath of await listFiles(sourcePath, mappings.source.uri)) {
-				const child = relative(sourcePath, filePath).split(sep).join("/");
-				const targetRelativePath = posix.join(operation.to, child);
-				assertNotReserved(targetRelativePath, reserved, mappings.source.uri);
-				entries.push({
-					sourcePath: filePath,
-					targetRelativePath,
-					mappingId: mapping.id
-				});
-			}
-		}
-	}
-	const seenTargets = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const prior = seenTargets.get(entry.targetRelativePath);
-		if (prior) throw new Error(`ResourceMappings duplicate target ${entry.targetRelativePath} from ${prior.sourcePath} and ${entry.sourcePath}`);
-		seenTargets.set(entry.targetRelativePath, entry);
-	}
-	return { entries: entries.sort((a, b) => a.targetRelativePath.localeCompare(b.targetRelativePath)) };
-}
-async function applyResourceMappingPlan(plan, outputRoot) {
-	const files = [];
-	for (const entry of plan.entries) {
-		const target = resolve(outputRoot, entry.targetRelativePath);
-		if (!isWithinRoot(resolve(outputRoot), target)) throw new Error(`ResourceMappings output escapes target root: ${entry.targetRelativePath}`);
-		await mkdir(dirname(target), { recursive: true });
-		await copyFile(entry.sourcePath, target);
-		files.push(entry.targetRelativePath);
-	}
-	return files;
-}
-function resolveSourceRoot(uri, roots, defaultSourceRoot, mappingUri) {
-	const moduleMatch = /^vfs:\/\/module\/([A-Z][A-Za-z0-9]*)\/(.*)$/.exec(uri);
-	if (moduleMatch) {
-		const base = roots.get(moduleMatch[1]);
-		if (!base) throw new Error(`Invalid ResourceMappings at ${mappingUri}: unknown module root ${moduleMatch[1]}`);
-		return safeResolve(resolve(base), moduleMatch[2], mappingUri);
-	}
-	const localMatch = /^vfs:\/\/@\/(.*)$/.exec(uri);
-	if (localMatch && defaultSourceRoot) return safeResolve(resolve(defaultSourceRoot), localMatch[1], mappingUri);
-	throw new Error(`Invalid ResourceMappings at ${mappingUri}: unsupported sourceRoot ${uri}`);
-}
-async function listFiles(root, uri) {
-	const files = [];
-	for (const entry of (await readdir(root, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-		const path = join(root, entry.name);
-		if (entry.isSymbolicLink()) throw new Error(`Invalid ResourceMappings at ${uri}: symbolic links are not supported: ${path}`);
-		if (entry.isDirectory()) files.push(...await listFiles(path, uri));
-		else if (entry.isFile()) files.push(path);
-		else throw new Error(`Invalid ResourceMappings at ${uri}: unsupported source entry ${path}`);
-	}
-	return files;
-}
-async function assertDirectory(path, uri, label) {
-	const info = await lstat(path).catch(() => void 0);
-	if (!info || info.isSymbolicLink() || !info.isDirectory()) throw new Error(`Invalid ResourceMappings at ${uri}: directory source does not exist: ${label}`);
-}
-async function assertFile(path, uri, label) {
-	const info = await lstat(path).catch(() => void 0);
-	if (!info || info.isSymbolicLink() || !info.isFile()) throw new Error(`Invalid ResourceMappings at ${uri}: file source does not exist: ${label}`);
-}
-function safeResolve(root, path, uri) {
-	const target = resolve(root, path);
-	if (!isWithinRoot(root, target)) throw new Error(`Invalid ResourceMappings at ${uri}: path escapes source root: ${path}`);
-	return target;
-}
-function isWithinRoot(root, target) {
-	return target === root || target.startsWith(`${root}${sep}`);
-}
-function assertNotReserved(path, reserved, uri) {
-	for (const item of reserved) if (pathsOverlap(path, item)) throw new Error(`Invalid ResourceMappings at ${uri}: target ${path} conflicts with generated target ${item}`);
-}
-function pathsOverlap(left, right) {
-	return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
-}
-function normalizeRelativePath(value, uri, attribute) {
-	if (!value.trim() || value.includes("\\") || value.startsWith("/") || isAbsolute(value) || value.split("/").includes("..")) throw new Error(`Invalid ResourceMappings at ${uri}: ${attribute} must be a safe relative path: ${value}`);
-	const normalized = posix.normalize(value).replace(/^\.\//, "").replace(/\/$/, "");
-	if (!normalized || normalized === "." || normalized.startsWith("../")) throw new Error(`Invalid ResourceMappings at ${uri}: ${attribute} must identify a non-root path: ${value}`);
-	return normalized;
-}
-function normalizeOutputDirectory(value, uri) {
-	return `${normalizeRelativePath(value, uri, "to")}/`;
-}
-function asRootMap(value) {
-	return typeof value.get === "function" ? value : new Map(Object.entries(value));
-}
-const resourceMappingPackage = {
-	role: "framework",
-	area: "resource-mapping",
-	owns: "declarative multi-root resource copy planning and collision preflight"
-};
-//#endregion
-export { resourceMappingPackage as i, parseResourceMappings as n, planResourceMappings as r, applyResourceMappingPlan as t };