@ucdjs/pipelines-loader 0.0.1-beta.6 → 0.0.1-beta.8

package/dist/chunk-DQk6qfdC.mjs

@@ -1,18 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
-export { __exportAll as t };

package/dist/insecure-lzOoh_sk.mjs

@@ -1,346 +0,0 @@
-import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
-import { isPipelineDefinition } from "@ucdjs/pipelines-core";
-import path from "node:path";
-import { build } from "rolldown";
-import { parseSync } from "oxc-parser";
-import { readFile } from "node:fs/promises";
-import { transform } from "oxc-transform";
-
-//#region src/bundler/identifiers.ts
-function isUrlLike(value) {
-	return /^[a-z][a-z+.-]*:/i.test(value);
-}
-function parseRemoteIdentifier(identifier) {
-	if (!identifier.startsWith("github://") && !identifier.startsWith("gitlab://")) return null;
-	const url = new URL(identifier);
-	const provider = url.protocol.replace(":", "");
-	const owner = url.hostname;
-	const repo = url.pathname.replace(/^\/+/, "");
-	if (!owner || !repo) throw new Error(`Invalid remote identifier: ${identifier}`);
-	return {
-		provider,
-		owner,
-		repo,
-		ref: url.searchParams.get("ref") ?? "HEAD",
-		path: url.searchParams.get("path") ?? ""
-	};
-}
-function formatRemoteIdentifier(remote) {
-	const url = new URL(`${remote.provider}://${remote.owner}/${remote.repo}`);
-	url.searchParams.set("ref", remote.ref);
-	url.searchParams.set("path", remote.path);
-	return url.toString();
-}
-function formatRemoteIdentifierFromParts(provider, owner, repo, ref, filePath) {
-	return formatRemoteIdentifier({
-		provider,
-		owner,
-		repo,
-		ref: ref ?? "HEAD",
-		path: filePath
-	});
-}
-
-//#endregion
-//#region src/bundler/errors.ts
-var RemoteNotFoundError = class extends Error {
-	name = "RemoteNotFoundError";
-	constructor(message) {
-		super(message);
-	}
-};
-
-//#endregion
-//#region src/bundler/parse.ts
-function getStaticImportSpecifiers(source, identifier) {
-	let parsed;
-	try {
-		parsed = parseSync(identifier ?? "<inline>", source, { sourceType: "module" });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to parse module ${identifier ?? "<inline>"}: ${message}`);
-	}
-	const specifiers = /* @__PURE__ */ new Set();
-	const visit = (value) => {
-		if (!value) return;
-		if (Array.isArray(value)) {
-			for (const item of value) visit(item);
-			return;
-		}
-		if (typeof value !== "object") return;
-		const node = value;
-		if (node.type === "ImportDeclaration") {
-			const sourceNode = node.source;
-			if (sourceNode?.value) specifiers.add(sourceNode.value);
-		} else if (node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") {
-			const sourceNode = node.source;
-			if (sourceNode?.value) specifiers.add(sourceNode.value);
-		} else if (node.type === "ImportExpression") {
-			const sourceNode = node.source ?? node.argument;
-			if (sourceNode?.type === "StringLiteral" && sourceNode.value) specifiers.add(sourceNode.value);
-		}
-		for (const [key, child] of Object.entries(node)) {
-			if (key === "parent") continue;
-			visit(child);
-		}
-	};
-	visit(parsed.program);
-	return Array.from(specifiers);
-}
-
-//#endregion
-//#region src/bundler/resolve.ts
-const EXTENSIONS = [
-	".ts",
-	".mts",
-	".js",
-	".mjs"
-];
-function assertRelativeSpecifier(specifier) {
-	if (isUrlLike(specifier)) throw new Error(`Unsupported import specifier: ${specifier}`);
-	if (!specifier.startsWith("./") && !specifier.startsWith("../")) throw new Error(`Unsupported import specifier: ${specifier}`);
-}
-function stripTrailingSlash(value) {
-	return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-function appendSuffix(identifier, suffix) {
-	const remote = parseRemoteIdentifier(identifier);
-	if (remote) return formatRemoteIdentifier({
-		...remote,
-		path: `${remote.path}${suffix}`
-	});
-	if (isUrlLike(identifier)) {
-		const url = new URL(identifier);
-		url.pathname = `${url.pathname}${suffix}`;
-		return url.toString();
-	}
-	return `${identifier}${suffix}`;
-}
-function resolveRelativeSpecifier(specifier, parentIdentifier) {
-	const remote = parseRemoteIdentifier(parentIdentifier);
-	if (remote) {
-		const parentDir = remote.path ? path.posix.dirname(remote.path) : "";
-		const cleanPath = path.posix.normalize(path.posix.join(parentDir, specifier)).replace(/^\/+/, "");
-		return formatRemoteIdentifier({
-			...remote,
-			path: cleanPath
-		});
-	}
-	if (isUrlLike(parentIdentifier)) {
-		const base = new URL(parentIdentifier);
-		return new URL(specifier, base).toString();
-	}
-	const parentDir = path.dirname(parentIdentifier);
-	return path.resolve(parentDir, specifier);
-}
-function getSpecifierExtension(specifier) {
-	return path.posix.extname(specifier);
-}
-function buildCandidateIdentifiers(specifier, parentIdentifier) {
-	const resolvedBase = resolveRelativeSpecifier(specifier, parentIdentifier);
-	if (getSpecifierExtension(specifier) !== "") return [resolvedBase];
-	const normalizedBase = stripTrailingSlash(resolvedBase);
-	const candidates = [];
-	for (const ext of EXTENSIONS) candidates.push(appendSuffix(normalizedBase, ext));
-	for (const ext of EXTENSIONS) candidates.push(appendSuffix(`${normalizedBase}/index`, ext));
-	return candidates;
-}
-
-//#endregion
-//#region src/remote/github.ts
-var github_exports = /* @__PURE__ */ __exportAll({
-	fetchFile: () => fetchFile$1,
-	listFiles: () => listFiles$1
-});
-const GITHUB_API_BASE = "https://api.github.com";
-const GITHUB_ACCEPT_HEADER = "application/vnd.github.v3+json";
-async function listFiles$1(repoRef, options = {}) {
-	const { owner, repo, ref = "HEAD", path = "" } = repoRef;
-	const { customFetch = fetch } = options;
-	const response = await customFetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`, { headers: { Accept: GITHUB_ACCEPT_HEADER } });
-	if (!response.ok) throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
-	const data = await response.json();
-	const prefix = path ? `${path}/` : "";
-	return {
-		files: data.tree.filter((item) => item.type === "blob" && item.path.startsWith(prefix)).map((item) => item.path),
-		truncated: data.truncated
-	};
-}
-async function fetchFile$1(repoRef, filePath, options = {}) {
-	const { owner, repo, ref = "HEAD" } = repoRef;
-	const { customFetch = fetch } = options;
-	const response = await customFetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}/contents/${encodeURIComponent(filePath)}?ref=${ref}`, { headers: { Accept: GITHUB_ACCEPT_HEADER } });
-	if (!response.ok) {
-		if (response.status === 404) throw new RemoteNotFoundError(`GitHub file not found: ${filePath}`);
-		throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
-	}
-	const data = await response.json();
-	if (data.encoding !== "base64") throw new Error(`Unexpected encoding: ${data.encoding}`);
-	return Buffer.from(data.content, "base64").toString("utf-8");
-}
-
-//#endregion
-//#region src/remote/gitlab.ts
-var gitlab_exports = /* @__PURE__ */ __exportAll({
-	fetchFile: () => fetchFile,
-	listFiles: () => listFiles
-});
-const GITLAB_API_BASE = "https://gitlab.com/api/v4";
-function encodeProjectPath(owner, repo) {
-	return encodeURIComponent(`${owner}/${repo}`);
-}
-async function listFiles(repoRef, options = {}) {
-	const { owner, repo, ref, path } = repoRef;
-	const refValue = ref ?? "HEAD";
-	const pathValue = path ?? "";
-	const { customFetch = fetch } = options;
-	const projectId = encodeProjectPath(owner, repo);
-	const encodedPath = encodeURIComponent(pathValue);
-	const files = [];
-	let truncated = false;
-	async function fetchPage(page) {
-		const response = await customFetch(`${GITLAB_API_BASE}/projects/${projectId}/repository/tree?recursive=true&ref=${refValue}&path=${encodedPath}&per_page=100&page=${page}`);
-		if (!response.ok) throw new Error(`GitLab API error: ${response.status} ${response.statusText}`);
-		const data = await response.json();
-		files.push(...data.filter((item) => item.type === "blob").map((item) => item.path));
-		const nextPage = response.headers.get("x-next-page");
-		if (!nextPage) return;
-		const nextPageNumber = Number(nextPage);
-		if (!Number.isFinite(nextPageNumber) || nextPageNumber <= page) {
-			truncated = true;
-			return;
-		}
-		await fetchPage(nextPageNumber);
-	}
-	await fetchPage(1);
-	return {
-		files,
-		truncated
-	};
-}
-async function fetchFile(repoRef, filePath, options = {}) {
-	const { owner, repo, ref } = repoRef;
-	const refValue = ref ?? "HEAD";
-	const { customFetch = fetch } = options;
-	const response = await customFetch(`${GITLAB_API_BASE}/projects/${encodeProjectPath(owner, repo)}/repository/files/${encodeURIComponent(filePath)}/raw?ref=${refValue}`);
-	if (!response.ok) {
-		if (response.status === 404) throw new RemoteNotFoundError(`GitLab file not found: ${filePath}`);
-		throw new Error(`GitLab API error: ${response.status} ${response.statusText}`);
-	}
-	return response.text();
-}
-
-//#endregion
-//#region src/bundler/source.ts
-async function loadRemoteSource(identifier, customFetch) {
-	const remote = parseRemoteIdentifier(identifier);
-	if (!remote) {
-		if (isUrlLike(identifier)) throw new Error(`Unsupported import specifier: ${identifier}`);
-		try {
-			return await readFile(identifier, "utf-8");
-		} catch (error) {
-			if (error instanceof Error && "code" in error && error.code === "ENOENT") throw new RemoteNotFoundError(`Module not found: ${identifier}`);
-			throw error;
-		}
-	}
-	const repoRef = {
-		owner: remote.owner,
-		repo: remote.repo,
-		ref: remote.ref
-	};
-	if (remote.provider === "github") return fetchFile$1(repoRef, remote.path, { customFetch });
-	return fetchFile(repoRef, remote.path, { customFetch });
-}
-async function compileModuleSource(identifier, source) {
-	let filename;
-	try {
-		const url = new URL(identifier);
-		filename = url.searchParams.get("path") ?? (url.pathname || identifier);
-	} catch {
-		filename = identifier;
-	}
-	const result = await transform(filename, source, { sourceType: "module" });
-	if (result.errors && result.errors.length > 0) {
-		const message = result.errors.map((error) => error.message).join("\n");
-		throw new Error(`Failed to parse module ${identifier}: ${message}`);
-	}
-	return result.code;
-}
-
-//#endregion
-//#region src/bundler/bundle.ts
-function createRemotePlugin(input) {
-	const customFetch = input.customFetch ?? fetch;
-	const moduleCache = /* @__PURE__ */ new Map();
-	return {
-		name: "pipeline-remote-loader",
-		resolveId: async (specifier, importer) => {
-			if (!importer) return input.identifier;
-			assertRelativeSpecifier(specifier);
-			const candidates = buildCandidateIdentifiers(specifier, importer);
-			for (const candidate of candidates) try {
-				const source = await loadRemoteSource(candidate, customFetch);
-				moduleCache.set(candidate, source);
-				return candidate;
-			} catch (err) {
-				if (err instanceof RemoteNotFoundError) continue;
-				throw err;
-			}
-			throw new Error(`Module not found: ${specifier}`);
-		},
-		load: async (id) => {
-			if (id === input.identifier) return compileModuleSource(id, input.content);
-			const source = moduleCache.get(id) ?? await loadRemoteSource(id, customFetch);
-			const code = await compileModuleSource(id, source);
-			moduleCache.set(id, source);
-			return code;
-		}
-	};
-}
-async function bundleRemoteModule(input) {
-	const specifiers = getStaticImportSpecifiers(input.content, input.identifier);
-	for (const specifier of specifiers) assertRelativeSpecifier(specifier);
-	const result = await build({
-		input: input.identifier,
-		plugins: [createRemotePlugin(input)],
-		write: false,
-		output: { format: "esm" }
-	});
-	const chunk = (Array.isArray(result) ? result : [result]).flatMap((output) => output.output ?? []).find((item) => item.type === "chunk");
-	if (!chunk || chunk.type !== "chunk") throw new Error("Failed to bundle remote module");
-	return chunk.code;
-}
-function createDataUrl(code) {
-	return `data:text/javascript;base64,${Buffer.from(code, "utf-8").toString("base64")}`;
-}
-function identifierForLocalFile(filePath) {
-	return path.resolve(filePath);
-}
-
-//#endregion
-//#region src/insecure.ts
-async function loadPipelineFromContent(content, filename, options = {}) {
-	const module = await import(createDataUrl(await bundleRemoteModule({
-		content,
-		identifier: options.identifier ?? identifierForLocalFile(path.resolve(filename)),
-		customFetch: options.customFetch
-	})));
-	const pipelines = [];
-	const exportNames = [];
-	const exportedModule = module;
-	for (const [name, value] of Object.entries(exportedModule)) {
-		if (name === "default") continue;
-		if (isPipelineDefinition(value)) {
-			pipelines.push(value);
-			exportNames.push(name);
-		}
-	}
-	return {
-		filePath: filename,
-		pipelines,
-		exportNames
-	};
-}
-
-//#endregion
-export { fetchFile$1 as a, formatRemoteIdentifierFromParts as c, listFiles as i, fetchFile as n, github_exports as o, gitlab_exports as r, listFiles$1 as s, loadPipelineFromContent as t };

package/dist/insecure.d.mts

@@ -1,10 +0,0 @@
-import { i as LoadedPipelineFile } from "./types-Br8gGmsN.mjs";
-
-//#region src/insecure.d.ts
-interface LoadPipelineFromContentOptions {
-  identifier?: string;
-  customFetch?: typeof fetch;
-}
-declare function loadPipelineFromContent(content: string, filename: string, options?: LoadPipelineFromContentOptions): Promise<LoadedPipelineFile>;
-//#endregion
-export { LoadPipelineFromContentOptions, loadPipelineFromContent };

package/dist/insecure.mjs

@@ -1,3 +0,0 @@
-import { t as loadPipelineFromContent } from "./insecure-lzOoh_sk.mjs";
-
-export { loadPipelineFromContent };

package/dist/remote-PQ_FXnt1.d.mts

@@ -1,46 +0,0 @@
-import { n as GitLabSource, r as LoadPipelinesResult, t as GitHubSource } from "./types-Br8gGmsN.mjs";
-
-//#region src/remote/types.d.ts
-interface RemoteFileList {
-  files: string[];
-  truncated: boolean;
-}
-interface RemoteRequestOptions {
-  customFetch?: typeof fetch;
-}
-declare namespace github_d_exports {
-  export { fetchFile$1 as fetchFile, listFiles$1 as listFiles };
-}
-interface GitHubRepoRef {
-  owner: string;
-  repo: string;
-  ref?: string;
-  path?: string;
-}
-declare function listFiles$1(repoRef: GitHubRepoRef, options?: RemoteRequestOptions): Promise<RemoteFileList>;
-declare function fetchFile$1(repoRef: GitHubRepoRef, filePath: string, options?: RemoteRequestOptions): Promise<string>;
-declare namespace gitlab_d_exports {
-  export { GitLabRepoRef, fetchFile, listFiles };
-}
-interface GitLabRepoRef {
-  owner: string;
-  repo: string;
-  ref?: string;
-  path?: string;
-}
-declare function listFiles(repoRef: GitLabRepoRef, options?: RemoteRequestOptions): Promise<RemoteFileList>;
-declare function fetchFile(repoRef: GitLabRepoRef, filePath: string, options?: RemoteRequestOptions): Promise<string>;
-//#endregion
-//#region src/remote.d.ts
-interface FindRemotePipelineFilesOptions {
-  pattern?: string;
-  customFetch?: typeof fetch;
-}
-declare function findRemotePipelineFiles(source: GitHubSource | GitLabSource, options?: FindRemotePipelineFilesOptions): Promise<RemoteFileList>;
-interface LoadRemotePipelinesOptions {
-  throwOnError?: boolean;
-  customFetch?: typeof fetch;
-}
-declare function loadRemotePipelines(source: GitHubSource | GitLabSource, filePaths: string[], options?: LoadRemotePipelinesOptions): Promise<LoadPipelinesResult>;
-//#endregion
-export { gitlab_d_exports as a, loadRemotePipelines as i, LoadRemotePipelinesOptions as n, github_d_exports as o, findRemotePipelineFiles as r, FindRemotePipelineFilesOptions as t };

package/dist/remote.d.mts

@@ -1,3 +0,0 @@
-import "./types-Br8gGmsN.mjs";
-import { a as gitlab_d_exports, i as loadRemotePipelines, n as LoadRemotePipelinesOptions, o as github_d_exports, r as findRemotePipelineFiles, t as FindRemotePipelineFilesOptions } from "./remote-PQ_FXnt1.mjs";
-export { FindRemotePipelineFilesOptions, LoadRemotePipelinesOptions, findRemotePipelineFiles, github_d_exports as github, gitlab_d_exports as gitlab, loadRemotePipelines };

package/dist/remote.mjs

@@ -1,76 +0,0 @@
-import { a as fetchFile, c as formatRemoteIdentifierFromParts, i as listFiles$1, n as fetchFile$1, o as github_exports, r as gitlab_exports, s as listFiles, t as loadPipelineFromContent } from "./insecure-lzOoh_sk.mjs";
-import picomatch from "picomatch";
-
-//#region src/remote.ts
-async function findRemotePipelineFiles(source, options = {}) {
-	const { pattern = "**/*.ucd-pipeline.ts", customFetch = fetch } = options;
-	const { owner, repo, ref, path } = source;
-	const repoRef = {
-		owner,
-		repo,
-		ref,
-		path
-	};
-	let fileList;
-	if (source.type === "github") fileList = await listFiles(repoRef, { customFetch });
-	else fileList = await listFiles$1(repoRef, { customFetch });
-	const isMatch = picomatch(pattern, { dot: true });
-	return {
-		files: fileList.files.filter((file) => isMatch(file)),
-		truncated: fileList.truncated
-	};
-}
-function buildRemoteIdentifier(provider, owner, repo, ref, filePath) {
-	return formatRemoteIdentifierFromParts(provider, owner, repo, ref, filePath);
-}
-async function loadRemotePipelines(source, filePaths, options = {}) {
-	const { throwOnError = false, customFetch = fetch } = options;
-	const { owner, repo, ref, type } = source;
-	const repoRef = {
-		owner,
-		repo,
-		ref
-	};
-	if (throwOnError) {
-		const wrapped = filePaths.map((filePath) => (type === "github" ? fetchFile(repoRef, filePath, { customFetch }) : fetchFile$1(repoRef, filePath, { customFetch })).then((content) => loadPipelineFromContent(content, filePath, {
-			identifier: buildRemoteIdentifier(type, owner, repo, ref, filePath),
-			customFetch
-		})).catch((err) => {
-			const error = err instanceof Error ? err : new Error(String(err));
-			throw new Error(`Failed to load pipeline file: ${filePath}`, { cause: error });
-		}));
-		const results = await Promise.all(wrapped);
-		return {
-			pipelines: results.flatMap((r) => r.pipelines),
-			files: results,
-			errors: []
-		};
-	}
-	const settled = await Promise.allSettled(filePaths.map(async (filePath) => {
-		return loadPipelineFromContent(type === "github" ? await fetchFile(repoRef, filePath, { customFetch }) : await fetchFile$1(repoRef, filePath, { customFetch }), filePath, {
-			identifier: buildRemoteIdentifier(type, owner, repo, ref, filePath),
-			customFetch
-		});
-	}));
-	const files = [];
-	const errors = [];
-	for (const [i, result] of settled.entries()) {
-		if (result.status === "fulfilled") {
-			files.push(result.value);
-			continue;
-		}
-		const error = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
-		errors.push({
-			filePath: filePaths[i],
-			error
-		});
-	}
-	return {
-		pipelines: files.flatMap((f) => f.pipelines),
-		files,
-		errors
-	};
-}
-
-//#endregion
-export { findRemotePipelineFiles, github_exports as github, gitlab_exports as gitlab, loadRemotePipelines };

package/dist/types-Br8gGmsN.d.mts

@@ -1,41 +0,0 @@
-import { PipelineDefinition } from "@ucdjs/pipelines-core";
-
-//#region src/types.d.ts
-interface LoadedPipelineFile {
-  filePath: string;
-  pipelines: PipelineDefinition[];
-  exportNames: string[];
-}
-interface LoadPipelinesResult {
-  pipelines: PipelineDefinition[];
-  files: LoadedPipelineFile[];
-  errors: PipelineLoadError[];
-}
-interface PipelineLoadError {
-  filePath: string;
-  error: Error;
-}
-interface GitHubSource {
-  type: "github";
-  id: string;
-  owner: string;
-  repo: string;
-  ref?: string;
-  path?: string;
-}
-interface GitLabSource {
-  type: "gitlab";
-  id: string;
-  owner: string;
-  repo: string;
-  ref?: string;
-  path?: string;
-}
-interface LocalSource {
-  type: "local";
-  id: string;
-  cwd: string;
-}
-type PipelineSource = LocalSource | GitHubSource | GitLabSource;
-//#endregion
-export { LocalSource as a, LoadedPipelineFile as i, GitLabSource as n, PipelineLoadError as o, LoadPipelinesResult as r, PipelineSource as s, GitHubSource as t };