@markless/bundler 0.1.0

package/dist/types-D6KerlYq.d.ts

@@ -0,0 +1,107 @@
+import * as _$_markless_compiler0 from "@markless/compiler";
+
+//#region src/types.d.ts
+type MarklessEnvironment = 'client' | 'server' | 'lib';
+type MarklessClientOutput = 'full' | 'symbols-only';
+type MarklessExecutionLogMode = 'auto' | 'never' | 'always';
+interface MarklessDevServer {
+  transformRequest: (url: string, environment: MarklessEnvironment) => Promise<unknown> | unknown;
+}
+interface MarklessRolldownOptions {
+  dev?: boolean;
+  devInjections?: GlobalInjections[];
+  devServer?: MarklessDevServer;
+  executionLog?: MarklessExecutionLogMode;
+  hmr?: boolean;
+  bundleGraphAdders?: Set<BundleGraphAdder>;
+  rootDir?: string;
+  buildId?: string;
+}
+type MarklessVirtualModuleType = 'payload' | 'resolver' | 'resume' | 'symbol' | 'style';
+interface MarklessVirtualModule {
+  id: string;
+  type: MarklessVirtualModuleType;
+  source: string;
+  symbolId?: string;
+  exportName?: string;
+}
+interface TransformTsrxModuleInput {
+  filename: string;
+  source: string;
+  devResumeReexport?: boolean;
+  buildId?: string;
+  environment?: MarklessEnvironment;
+  clientOutput?: MarklessClientOutput;
+  resumeModuleUrl?: string;
+  headInjections?: GlobalInjections[];
+  executionLog?: MarklessExecutionLogMode;
+  executionLogModuleHooks?: boolean;
+}
+interface TransformTsrxModuleResult {
+  code: string;
+  map: null;
+  virtualModules: MarklessVirtualModule[];
+  manifest: MarklessTransformManifest;
+}
+interface MarklessTransformManifest {
+  source: string;
+  payload: MarklessBuildModuleReference;
+  resolver: MarklessBuildModuleReference;
+  symbols: MarklessSymbolManifestEntry[];
+  runtimeDemandMap?: RuntimeDemandMapManifest;
+}
+interface MarklessBuildModuleReference {
+  virtualModuleId: string;
+  fileName?: string;
+}
+interface MarklessSymbolManifestEntry extends MarklessBuildModuleReference {
+  symbolId: string;
+  exportName: string;
+  kind: string;
+}
+type RuntimeDemandMapManifest = Omit<_$_markless_compiler0.RuntimeDemandMapArtifact, 'passId'>;
+interface MarklessBuildMetadata {
+  version: number;
+  modules: MarklessTransformManifest[];
+  bundles: Record<string, MarklessBundle>;
+  assets?: Record<string, MarklessAsset>;
+  bundleGraph?: MarklessBundleGraph;
+  bundleGraphAsset?: string;
+  injections?: GlobalInjections[];
+}
+type MarklessManifest = MarklessBuildMetadata;
+interface MarklessBundle {
+  size: number;
+  total: number;
+  symbols?: string[];
+  imports?: string[];
+  dynamicImports?: string[];
+  origins?: string[];
+}
+type MarklessAsset = {
+  name: string | undefined;
+  size: number;
+};
+type GlobalInjections = {
+  tag: string;
+  attributes?: Record<string, string>;
+  children?: string;
+  location: 'head' | 'body';
+};
+type MarklessBundleGraph = Array<string | number>;
+type PreloadGraphEntries = Record<string, {
+  imports?: string[];
+  dynamicImports?: string[];
+}>;
+interface PreloadGraphContext {
+  readonly manifest: MarklessBuildMetadata;
+  readonly hasBundle: (bundleName: string) => boolean;
+  readonly bundlesForOrigins: (origins: readonly string[]) => string[];
+}
+type PreloadGraphEntriesAdder = (context: PreloadGraphContext) => PreloadGraphEntries | undefined;
+type BundleGraphAdder = (manifest: MarklessBuildMetadata) => PreloadGraphEntries | undefined;
+type MarklessRolldownPluginApi = {
+  invalidateGeneratedModules: (parent: string, environment?: MarklessEnvironment) => string[];
+};
+//#endregion
+export { TransformTsrxModuleInput as _, MarklessBundle as a, MarklessEnvironment as c, MarklessRolldownPluginApi as d, MarklessTransformManifest as f, PreloadGraphEntriesAdder as g, PreloadGraphEntries as h, MarklessBuildMetadata as i, MarklessManifest as l, PreloadGraphContext as m, GlobalInjections as n, MarklessBundleGraph as o, MarklessVirtualModule as p, MarklessAsset as r, MarklessDevServer as s, BundleGraphAdder as t, MarklessRolldownOptions as u, TransformTsrxModuleResult as v };

package/dist/vite.d.ts

@@ -0,0 +1,12 @@
+import { c as MarklessEnvironment, g as PreloadGraphEntriesAdder, h as PreloadGraphEntries, i as MarklessBuildMetadata, l as MarklessManifest, m as PreloadGraphContext, n as GlobalInjections, t as BundleGraphAdder, u as MarklessRolldownOptions } from "./types-D6KerlYq.js";
+import { Plugin } from "vite";
+
+//#region src/vite/index.d.ts
+interface MarklessViteOptions extends MarklessRolldownOptions {
+  clientEnvironment?: string;
+  serverEnvironment?: string;
+}
+declare function markless(options?: MarklessViteOptions): Plugin[];
+type MarklessVitePlugin = ReturnType<typeof markless>[number];
+//#endregion
+export { type BundleGraphAdder, type GlobalInjections, type MarklessBuildMetadata, type MarklessEnvironment, type MarklessManifest, type MarklessRolldownOptions, MarklessViteOptions, MarklessVitePlugin, type PreloadGraphContext, type PreloadGraphEntries, type PreloadGraphEntriesAdder, markless };

package/dist/vite.js

@@ -0,0 +1,387 @@
+import { b as outputDefaults, p as executionLogActivationInjection } from "./source-module-CSRzW4Ny.js";
+import { l as createPreloadGraphAdder, t as createMarklessRolldownPlugin } from "./rolldown-Czh1duwk.js";
+import { joinURL, parsePath } from "ufo";
+//#region src/vite/dev-tags.ts
+function createDevTags() {
+	const tags = [];
+	let viteTagsAdded = false;
+	return {
+		tags,
+		register(tag) {
+			tags.push(tag);
+		},
+		registerViteTags(base) {
+			if (viteTagsAdded) return;
+			viteTagsAdded = true;
+			tags.unshift(headScript(base, "/@vite/client"));
+		}
+	};
+}
+function headScript(base, src) {
+	return {
+		tag: "script",
+		location: "head",
+		attributes: {
+			type: "module",
+			src: joinURL(base, src)
+		}
+	};
+}
+//#endregion
+//#region src/vite/environment.ts
+const UNMANAGED_VITE_ENVIRONMENTS = new Set(["nitro"]);
+function viteEnvironmentName(environment, options = {}) {
+	if (environment === "client") return options.clientEnvironment ?? "client";
+	if (environment === "server") return options.serverEnvironment ?? "ssr";
+	return environment;
+}
+function marklessEnvironment(environment) {
+	const config = environment?.config;
+	if (isUnmanagedViteEnvironment(environment)) return "lib";
+	if (!config) return "client";
+	if (config.build?.lib) return "lib";
+	if (isServerViteEnvironment(environment)) return "server";
+	return "client";
+}
+function isServerViteEnvironment(environment) {
+	if (isUnmanagedViteEnvironment(environment)) return false;
+	const consumer = environment?.config?.consumer;
+	if (consumer) return consumer === "server";
+	return environment?.name !== void 0 && environment.name !== "client";
+}
+function isUnmanagedViteEnvironment(environment) {
+	return !!environment?.name && UNMANAGED_VITE_ENVIRONMENTS.has(environment.name);
+}
+function transformMarklessRequest(server, url, environment, options) {
+	return server.environments[viteEnvironmentName(environment, options)]?.transformRequest(url);
+}
+function fetchableDevEnvironment(environment) {
+	if (!environment) return;
+	const maybeFetchable = environment;
+	if (typeof maybeFetchable.dispatchFetch === "function") return maybeFetchable;
+}
+//#endregion
+//#region src/vite/hmr.ts
+const SOURCE_FILE_EXTENSION = /\.tsrx(?:[?#].*)?$/;
+function createViteHmr(options) {
+	let server;
+	return {
+		configureServer(nextServer) {
+			server = nextServer;
+			if (options.enabled) installFetchViteClient(nextServer, options);
+		},
+		transformIndexHtml() {},
+		resolveId(_id) {
+			return null;
+		},
+		load(_id) {
+			return null;
+		},
+		hotUpdate(environment, ctx) {
+			if (!environment) return;
+			const env = marklessEnvironment(environment);
+			if (env === "lib") return;
+			const hot = env === "server" ? server?.environments?.[options.clientEnvironment]?.hot : environment.hot;
+			if (!hot?.send) return;
+			if (!options.enabled) {
+				hot.send({ type: "full-reload" });
+				return [];
+			}
+			const files = changedFiles(ctx.modules ?? []);
+			const root = server?.config?.root;
+			if (ctx.file && SOURCE_FILE_EXTENSION.test(ctx.file)) {
+				const prefix = root && `${root}/`;
+				files.add(prefix && ctx.file.startsWith(prefix) ? `/${ctx.file.slice(prefix.length)}` : ctx.file);
+			}
+			if (!files.size) return;
+			const invalidationEnvironments = moduleGraphEnvironments(environment, env === "server" ? server?.environments?.[options.clientEnvironment] : void 0);
+			for (const file of files) for (const candidate of hmrCandidates(file, ctx.file)) for (const id of options.invalidateGeneratedModules?.(candidate, env) ?? []) for (const targetEnvironment of invalidationEnvironments) {
+				const module = targetEnvironment.moduleGraph?.getModuleById?.(id);
+				if (!module) continue;
+				targetEnvironment.moduleGraph?.invalidateModule?.(module, /* @__PURE__ */ new Set(), ctx.timestamp, true);
+			}
+			hot.send({
+				type: "full-reload",
+				path: firstChangedFile(files),
+				triggeredBy: ctx.file
+			});
+			return [];
+		}
+	};
+}
+function installFetchViteClient(server, options) {
+	for (const environment of Object.values(server.environments)) {
+		const fetchEnv = fetchableDevEnvironment(environment);
+		if (!fetchEnv) continue;
+		const dispatchFetch = fetchEnv.dispatchFetch.bind(fetchEnv);
+		fetchEnv.dispatchFetch = async (request) => {
+			const response = await dispatchFetch(request);
+			if (!response.headers.get("content-type")?.includes("text/html")) return response;
+			const html = await response.text();
+			const nextHtml = injectViteClient(html, options.base);
+			const headers = new Headers(response.headers);
+			if (nextHtml !== html) headers.delete("content-length");
+			return new Response(nextHtml, {
+				headers,
+				status: response.status,
+				statusText: response.statusText
+			});
+		};
+	}
+}
+function injectViteClient(html, base) {
+	if (!html || html.includes("/@vite/client")) return html;
+	const tag = `<script type="module" src="${joinURL(base, "/@vite/client")}"><\/script>`;
+	if (html.includes("</head>")) return html.replace("</head>", `${tag}</head>`);
+	if (html.includes("<head>")) return html.replace("<head>", `<head>${tag}`);
+	return `${tag}${html}`;
+}
+function changedFiles(modules) {
+	const files = /* @__PURE__ */ new Set();
+	for (const module of modules) for (const item of [module, ...module.importers ?? []]) {
+		const url = sourceUrl(item);
+		if (url) files.add(url);
+	}
+	return files;
+}
+function sourceUrl(module) {
+	const url = parsePath(module.url).pathname;
+	if (module.type === "js" && SOURCE_FILE_EXTENSION.test(url)) return url;
+	return null;
+}
+function hmrCandidates(file, absoluteFile) {
+	const candidates = new Set([file]);
+	if (absoluteFile) candidates.add(absoluteFile);
+	return candidates;
+}
+function moduleGraphEnvironments(environment, clientEnvironment) {
+	if (!clientEnvironment || clientEnvironment === environment) return [environment];
+	return [environment, clientEnvironment];
+}
+function firstChangedFile(files) {
+	for (const file of files) return file;
+}
+//#endregion
+//#region src/vite/index.ts
+const MARKLESS_SKIP_DUPLICATE_BUILDS = Symbol("markless-skip-duplicate-builds");
+const TSRX_INPUT_FILE = /\.tsrx(?:[?#].*)?$/;
+function markless(options = {}) {
+	let command = "build";
+	const bundleGraphAdders = /* @__PURE__ */ new Set();
+	const transformedTsrxSources = /* @__PURE__ */ new Map();
+	const rolldownOptions = { ...options };
+	rolldownOptions.bundleGraphAdders = bundleGraphAdders;
+	const hmrOptions = {
+		base: "/",
+		clientEnvironment: viteEnvironmentName("client", options),
+		enabled: false,
+		invalidateGeneratedModules: (parent, environment) => marklessPlugin.api.invalidateGeneratedModules(parent, environment)
+	};
+	const devTags = createDevTags();
+	rolldownOptions.devInjections = devTags.tags;
+	const basePlugin = createMarklessRolldownPlugin({
+		environment: getBuildEnvironment,
+		options: rolldownOptions
+	});
+	const hmr = createViteHmr(hmrOptions);
+	const marklessPlugin = {
+		...basePlugin,
+		name: "vite-plugin-markless",
+		enforce: "post",
+		sharedDuringBuild: true,
+		api: {
+			...basePlugin.api,
+			registerBundleGraphAdder: (adder) => bundleGraphAdders.add(adder),
+			registerDevInjection: (injection) => devTags.register(injection),
+			registerPreloadGraphEntries: (adder) => bundleGraphAdders.add(createPreloadGraphAdder(adder))
+		},
+		config(config, env) {
+			command = env.command;
+			configDefaults(config, options, rolldownOptions);
+		},
+		configResolved(resolvedConfig) {
+			const serve = resolvedConfig.command === "serve";
+			hmrOptions.base = resolvedConfig.base;
+			hmrOptions.enabled = serve && options.hmr !== false;
+			rolldownOptions.dev = serve;
+			rolldownOptions.rootDir = resolvedConfig.root;
+			rolldownOptions.publicPath = (fileName) => joinURL(resolvedConfig.base, fileName);
+			if (serve) devTags.registerViteTags(resolvedConfig.base);
+		},
+		configEnvironment(name, config) {
+			if (command === "serve") return;
+			const environment = configEnvironmentKind(name, config, options);
+			if (!environment) return;
+			const build = config.build ?? {};
+			const rolldownOptions = build.rolldownOptions ?? {};
+			const outDir = defaultOutDir(environment);
+			return { build: {
+				...build,
+				...environment === "client" ? { modulePreload: build.modulePreload ?? false } : {},
+				...build.outDir || !outDir ? {} : { outDir },
+				rolldownOptions: {
+					...rolldownOptions,
+					output: withOutputDefaults(rolldownOptions.output, environment)
+				}
+			} };
+		},
+		buildApp: {
+			order: "pre",
+			handler(builder) {
+				return buildMarklessEnvironments(builder, options);
+			}
+		},
+		configureServer(server) {
+			rolldownOptions.devServer = { transformRequest: (url, environment) => transformMarklessRequest(server, url, environment, options) };
+			hmr.configureServer(server);
+		},
+		transformIndexHtml() {
+			const hmrResult = hmr.transformIndexHtml();
+			const injection = executionLogActivationInjection(rolldownOptions.executionLog);
+			if (!injection) return hmrResult;
+			const tag = {
+				tag: injection.tag,
+				injectTo: injection.location,
+				attrs: injection.attributes,
+				children: injection.children
+			};
+			return Array.isArray(hmrResult) ? [...hmrResult, tag] : [tag];
+		},
+		resolveId: {
+			order: "pre",
+			async handler(source, importer, opts) {
+				const hmrResolved = hmr.resolveId(source);
+				if (hmrResolved) return hmrResolved;
+				return runHook(basePlugin.resolveId, this, source, importer, opts);
+			}
+		},
+		load(id, loadOptions) {
+			return hmr.load(id) ?? runHook(basePlugin.load, this, id, loadOptions);
+		},
+		transform: { async handler(code, id, transformOptions) {
+			if (rolldownOptions.dev === true && TSRX_INPUT_FILE.test(id)) transformedTsrxSources.set(parsePath(id).pathname, code);
+			return runHook(basePlugin.transform, this, code, id, transformOptions);
+		} },
+		async hotUpdate(ctx) {
+			if (await matchesTransformedTsrxSource(ctx, transformedTsrxSources)) return [];
+			return hmr.hotUpdate(this.environment, ctx);
+		}
+	};
+	return [marklessPlugin];
+}
+async function buildMarklessEnvironments(builder, options) {
+	const environments = buildEnvironments(builder, options);
+	skipDuplicateBuilds(builder, environments.map((environment) => environment.name));
+	for (const environment of environments) if (!environment.isBuilt) await builder.build(environment);
+}
+function buildEnvironments(builder, options) {
+	const environments = /* @__PURE__ */ new Map();
+	for (const name of [viteEnvironmentName("client", options), viteEnvironmentName("server", options)]) {
+		const environment = builder.environments[name];
+		if (environment) environments.set(name, environment);
+	}
+	for (const environment of Object.values(builder.environments)) if (marklessEnvironment(environment) === "server") environments.set(environment.name, environment);
+	return [...environments.values()];
+}
+function skipDuplicateBuilds(builder, names) {
+	const guarded = builder;
+	const guardedNames = guarded[MARKLESS_SKIP_DUPLICATE_BUILDS] ?? /* @__PURE__ */ new Set();
+	for (const name of names) guardedNames.add(name);
+	if (guarded[MARKLESS_SKIP_DUPLICATE_BUILDS]) return;
+	guarded[MARKLESS_SKIP_DUPLICATE_BUILDS] = guardedNames;
+	const build = builder.build.bind(builder);
+	builder.build = (environment) => {
+		if (guardedNames.has(environment.name) && environment.isBuilt) return Promise.resolve([]);
+		return build(environment);
+	};
+}
+function configDefaults(config, options, internalOptions) {
+	const dynamicImportVars = (config.build ??= {}).dynamicImportVarsOptions ??= {};
+	dynamicImportVars.exclude = [...Array.isArray(dynamicImportVars.exclude) ? dynamicImportVars.exclude : dynamicImportVars.exclude ? [dynamicImportVars.exclude] : [], /\.tsrx(?:[?#]|$)/];
+	if (config.build?.lib || config.build?.ssr) return;
+	const build = config.build ??= {};
+	const ssrSymbolInput = ssrTsrxInput(config, options);
+	if (ssrSymbolInput) {
+		internalOptions.emitResumeModules = true;
+		const rolldownOptions = build.rolldownOptions ??= {};
+		rolldownOptions.input = withSsrSymbolInput(rolldownOptions.input, ssrSymbolInput);
+	}
+	build.modulePreload ??= false;
+}
+function ssrTsrxInput(config, options) {
+	const ssr = config.environments?.[viteEnvironmentName("server", options)];
+	return firstTsrxInput(ssr?.build?.rolldownOptions?.input);
+}
+function firstTsrxInput(input) {
+	if (typeof input === "string") return TSRX_INPUT_FILE.test(input) ? input : null;
+	if (Array.isArray(input)) {
+		for (const item of input) {
+			const match = firstTsrxInput(item);
+			if (match) return match;
+		}
+		return null;
+	}
+	if (input && typeof input === "object") for (const value of Object.values(input)) {
+		const match = firstTsrxInput(value);
+		if (match) return match;
+	}
+	return null;
+}
+function withSsrSymbolInput(input, ssrSymbolInput) {
+	if (isRolldownInputRecord(input)) {
+		if (Object.keys(input).some((name) => /symbol/i.test(name))) return input;
+		return {
+			...input,
+			symbols: ssrSymbolInput
+		};
+	}
+	if (typeof input === "string") {
+		const name = input.endsWith(".html") ? "index" : "app";
+		return input === ssrSymbolInput ? { symbols: ssrSymbolInput } : {
+			[name]: input,
+			symbols: ssrSymbolInput
+		};
+	}
+	if (Array.isArray(input)) return Object.fromEntries([...input.map((entry, index) => [`input${index}`, entry]), ["symbols", ssrSymbolInput]]);
+	return { symbols: ssrSymbolInput };
+}
+function isRolldownInputRecord(input) {
+	return !!input && typeof input === "object" && !Array.isArray(input);
+}
+function withOutputDefaults(output, environment) {
+	if (Array.isArray(output)) return output.map((item) => outputDefaults(item, environment));
+	if (!output) return outputDefaults({}, environment);
+	return outputDefaults(output, environment);
+}
+function defaultOutDir(environment) {
+	if (environment === "server") return "dist/server";
+}
+function configEnvironmentKind(name, config, options) {
+	if (config.build?.lib) return null;
+	if (name === viteEnvironmentName("client", options)) return "client";
+	if (name === viteEnvironmentName("server", options)) return "server";
+	if (isServerViteEnvironment({
+		name,
+		config
+	})) return "server";
+	return null;
+}
+async function matchesTransformedTsrxSource(ctx, transformedSources) {
+	if (!ctx.file || ctx.type === "delete" || typeof ctx.read !== "function") return false;
+	const transformedSource = transformedSources.get(ctx.file);
+	if (transformedSource === void 0) return false;
+	try {
+		return await ctx.read() === transformedSource;
+	} catch {
+		return false;
+	}
+}
+function runHook(hook, context, ...args) {
+	if (typeof hook !== "function") return null;
+	return hook.call(context, ...args);
+}
+function getBuildEnvironment(context) {
+	return marklessEnvironment(context.environment);
+}
+//#endregion
+export { markless };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@markless/bundler",
+  "version": "0.1.0",
+  "description": "Markless build plugins for Rolldown and Vite.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/markless-dev/markless.git",
+    "directory": "packages/bundler"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./preload": {
+      "types": "./dist/preload.d.ts",
+      "default": "./dist/preload.js"
+    },
+    "./rolldown": {
+      "types": "./dist/rolldown.d.ts",
+      "default": "./dist/rolldown.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "default": "./dist/vite.js"
+    }
+  },
+  "dependencies": {
+    "@thi.ng/dgraph": "^2.1.205",
+    "pathe": "^2.0.3",
+    "ufo": "^1.6.4",
+    "@markless/compiler": "0.1.0",
+    "@markless/web": "0.1.0"
+  },
+  "peerDependencies": {
+    "rolldown": "1.0.3",
+    "vite": "8.0.16"
+  },
+  "peerDependenciesMeta": {
+    "rolldown": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test:boxes": "witness run"
+  }
+}