@codespark/framework 1.0.0

package/dist/loaders.d.ts

@@ -0,0 +1,87 @@
+//#region src/loaders/types.d.ts
+declare enum LoaderType {
+  ESModule = "esmodule",
+  Style = "style",
+  Script = "script",
+  Asset = "asset",
+}
+interface BaseLoaderOutput<T extends LoaderType> {
+  type: T;
+  content: string;
+}
+interface ESModuleLoaderOutput extends BaseLoaderOutput<LoaderType.ESModule> {
+  dependencies: Record<string, string>;
+  externals: {
+    name: string;
+    imported: string[];
+  }[];
+}
+interface StyleLoaderOutput extends BaseLoaderOutput<LoaderType.Style> {
+  imports: string[];
+  href?: string;
+  attributes?: Record<string, string>;
+}
+interface ScriptLoaderOutput extends BaseLoaderOutput<LoaderType.Script> {
+  src?: string;
+  attributes?: Record<string, string>;
+}
+type AssetLoaderOutput = BaseLoaderOutput<LoaderType.Asset>;
+type LoaderOutput<T extends LoaderType> = Extract<ESModuleLoaderOutput | StyleLoaderOutput | ScriptLoaderOutput | AssetLoaderOutput, {
+  type: T;
+}>;
+interface LoaderContext {
+  resourcePath: string;
+  getSource: (path: string) => string | undefined;
+  resolve: (source: string) => string | null;
+}
+interface Loader<T extends LoaderType> {
+  readonly name: string;
+  readonly test: RegExp;
+  transform(source: string, ctx?: LoaderContext): LoaderOutput<T>;
+}
+//#endregion
+//#region src/loaders/css-loader.d.ts
+declare class CSSLoader implements Loader<LoaderType.Style> {
+  private config?;
+  readonly name = "css-loader";
+  readonly test: RegExp;
+  constructor(config?: {
+    tailwind?: {
+      enabled?: boolean;
+      match?: RegExp;
+    };
+  } | undefined);
+  transform(source: string, ctx: LoaderContext): StyleLoaderOutput;
+}
+//#endregion
+//#region src/loaders/es-loader.d.ts
+interface ESLoaderOptions {
+  /** JSX preset, e.g. [availablePresets.react, { runtime: 'automatic' }] */
+  jsxPreset?: [unknown, Record<string, unknown>];
+  /** Whether to enable TSX support, default false */
+  isTSX?: boolean;
+}
+declare class ESLoader implements Loader<LoaderType.ESModule> {
+  readonly name = "es-loader";
+  readonly test: RegExp;
+  private jsxPreset;
+  private isTSX;
+  constructor(options?: ESLoaderOptions);
+  transform(source: string, ctx: LoaderContext): ESModuleLoaderOutput;
+}
+//#endregion
+//#region src/loaders/json-loader.d.ts
+declare class JSONLoader implements Loader<LoaderType.ESModule> {
+  readonly name = "json-loader";
+  readonly test: RegExp;
+  transform(source: string): ESModuleLoaderOutput;
+}
+//#endregion
+//#region src/loaders/markdown-loader.d.ts
+declare class MarkdownLoader implements Loader<LoaderType.Asset> {
+  readonly name = "markdown-loader";
+  readonly test: RegExp;
+  transform(source: string): AssetLoaderOutput;
+}
+//#endregion
+export { AssetLoaderOutput, CSSLoader, ESLoader, ESLoaderOptions, ESModuleLoaderOutput, JSONLoader, Loader, LoaderContext, LoaderOutput, LoaderType, MarkdownLoader, ScriptLoaderOutput, StyleLoaderOutput };

package/dist/loaders.js

@@ -0,0 +1,175 @@
+import { parse } from "@babel/parser";
+import { availablePresets, transform } from "@babel/standalone";
+import DOMPurify from "dompurify";
+import { marked } from "marked";
+
+//#region src/loaders/types.ts
+let LoaderType = /* @__PURE__ */ function(LoaderType$1) {
+	LoaderType$1["ESModule"] = "esmodule";
+	LoaderType$1["Style"] = "style";
+	LoaderType$1["Script"] = "script";
+	LoaderType$1["Asset"] = "asset";
+	return LoaderType$1;
+}({});
+
+//#endregion
+//#region src/loaders/css-loader.ts
+var CSSLoader = class {
+	name = "css-loader";
+	test = /\.css$/;
+	constructor(config) {
+		this.config = config;
+	}
+	transform(source, ctx) {
+		const { enabled = true, match } = this.config?.tailwind || {};
+		const isTailwind = match ? match.test(ctx.resourcePath) : ctx.resourcePath.endsWith(".tw.css");
+		const imports = [];
+		const content = source.replace(/@import\s+(?:url\()?['"]?([^'")]+)['"]?\)?\s*;?/g, (_, importPath) => {
+			const resolved = ctx.resolve(importPath);
+			if (resolved) imports.push(resolved);
+			return "";
+		});
+		return {
+			type: LoaderType.Style,
+			content,
+			imports,
+			attributes: enabled && isTailwind ? { type: "text/tailwindcss" } : {}
+		};
+	}
+};
+
+//#endregion
+//#region src/loaders/es-loader.ts
+const parseCode = (code) => parse(code, {
+	sourceType: "module",
+	plugins: ["jsx", "typescript"]
+}).program.body;
+const collectIdentifiers = (ast) => {
+	const ids = /* @__PURE__ */ new Set();
+	const walk = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (node.type === "Identifier" || node.type === "JSXIdentifier") ids.add(node.name);
+		for (const k of Object.keys(node)) {
+			if (k === "loc" || k === "range") continue;
+			const val = node[k];
+			if (Array.isArray(val)) val.forEach(walk);
+			else if (val && typeof val === "object") walk(val);
+		}
+	};
+	ast.forEach(walk);
+	return ids;
+};
+const analyzeImports = (ast) => {
+	const imports = ast.filter((node) => node.type === "ImportDeclaration");
+	const usedIds = collectIdentifiers(ast.filter((node) => node.type !== "ImportDeclaration"));
+	const importMap = /* @__PURE__ */ new Map();
+	imports.forEach((imp) => {
+		if (imp.importKind === "type") return;
+		imp.specifiers.forEach((spec) => {
+			if (spec.type === "ImportSpecifier" && spec.importKind === "type") return;
+			importMap.set(spec.local.name, imp.source.value);
+		});
+	});
+	const usedSources = /* @__PURE__ */ new Set();
+	usedIds.forEach((id) => {
+		if (importMap.has(id)) usedSources.add(importMap.get(id));
+	});
+	return {
+		imports,
+		usedSources
+	};
+};
+const buildExternalDeps = (imports, usedSources) => {
+	const externals = /* @__PURE__ */ new Map();
+	imports.forEach((imp) => {
+		if (imp.importKind === "type") return;
+		const source = imp.source.value;
+		if (!usedSources.has(source) || source.startsWith(".") || source.startsWith("/")) return;
+		const namedImports = imp.specifiers.filter((spec) => spec.type === "ImportSpecifier" && spec.importKind !== "type").map((spec) => spec.imported.name);
+		const existing = externals.get(source);
+		if (existing) namedImports.forEach((name) => existing.imported.add(name));
+		else externals.set(source, {
+			name: source,
+			imported: new Set(namedImports)
+		});
+	});
+	return [...externals.values()].map((dep) => ({
+		...dep,
+		imported: [...dep.imported]
+	}));
+};
+var ESLoader = class {
+	name = "es-loader";
+	test = /\.(tsx?|jsx?)$/;
+	jsxPreset;
+	isTSX;
+	constructor(options) {
+		const { jsxPreset, isTSX = false } = options || {};
+		this.jsxPreset = jsxPreset;
+		this.isTSX = isTSX;
+	}
+	transform(source, ctx) {
+		const { imports, usedSources } = analyzeImports(parseCode(source));
+		const externals = buildExternalDeps(imports, usedSources);
+		const dependencies = {};
+		for (const imp of imports) {
+			if (imp.importKind === "type") continue;
+			const importPath = imp.source.value;
+			if (imp.specifiers.length === 0) {
+				const resolved$1 = ctx.resolve(importPath);
+				if (resolved$1) dependencies[importPath] = resolved$1;
+				continue;
+			}
+			if (!usedSources.has(importPath)) continue;
+			const resolved = ctx.resolve(importPath);
+			if (resolved) dependencies[importPath] = resolved;
+		}
+		const { typescript } = availablePresets;
+		const defaultPresets = [typescript, {
+			isTSX: this.isTSX,
+			allExtensions: true
+		}];
+		const { code } = transform(source, {
+			filename: ctx.resourcePath,
+			presets: this.jsxPreset ? [this.jsxPreset, defaultPresets] : [defaultPresets]
+		});
+		return {
+			type: LoaderType.ESModule,
+			content: code || "",
+			dependencies,
+			externals
+		};
+	}
+};
+
+//#endregion
+//#region src/loaders/json-loader.ts
+var JSONLoader = class {
+	name = "json-loader";
+	test = /\.json$/;
+	transform(source) {
+		return {
+			type: LoaderType.ESModule,
+			content: `export default ${source};`,
+			dependencies: {},
+			externals: []
+		};
+	}
+};
+
+//#endregion
+//#region src/loaders/markdown-loader.ts
+var MarkdownLoader = class {
+	name = "markdown-loader";
+	test = /\.md$/;
+	transform(source) {
+		const html = DOMPurify.sanitize(marked.parse(source, { async: false }));
+		return {
+			type: LoaderType.Asset,
+			content: html
+		};
+	}
+};
+
+//#endregion
+export { CSSLoader, ESLoader, JSONLoader, LoaderType, MarkdownLoader };

package/dist/markdown.d.ts

@@ -0,0 +1,52 @@
+import { Framework as Framework$1 } from "@codespark/framework";
+import "magic-string";
+
+//#region src/loaders/types.d.ts
+declare enum LoaderType {
+  ESModule = "esmodule",
+  Style = "style",
+  Script = "script",
+  Asset = "asset",
+}
+interface BaseLoaderOutput<T extends LoaderType> {
+  type: T;
+  content: string;
+}
+interface ESModuleLoaderOutput extends BaseLoaderOutput<LoaderType.ESModule> {
+  dependencies: Record<string, string>;
+  externals: {
+    name: string;
+    imported: string[];
+  }[];
+}
+interface StyleLoaderOutput extends BaseLoaderOutput<LoaderType.Style> {
+  imports: string[];
+  href?: string;
+  attributes?: Record<string, string>;
+}
+interface ScriptLoaderOutput extends BaseLoaderOutput<LoaderType.Script> {
+  src?: string;
+  attributes?: Record<string, string>;
+}
+type AssetLoaderOutput = BaseLoaderOutput<LoaderType.Asset>;
+type LoaderOutput<T extends LoaderType> = Extract<ESModuleLoaderOutput | StyleLoaderOutput | ScriptLoaderOutput | AssetLoaderOutput, {
+  type: T;
+}>;
+//#endregion
+//#region src/registry.d.ts
+type Output<T extends LoaderType = LoaderType> = Omit<LoaderOutput<T>, 'type'> & {
+  path: string;
+};
+type Outputs = Map<LoaderType, Output[]>;
+//#endregion
+//#region src/markdown/index.d.ts
+declare class Framework extends Framework$1 {
+  readonly name = "markdown";
+  readonly imports: {};
+  outputs: Outputs;
+  analyze(entry: string, files: Record<string, string>): void;
+  compile(): any;
+}
+declare const markdown: Framework;
+//#endregion
+export { Framework, markdown };

package/dist/markdown.js

@@ -0,0 +1,75 @@
+import { Framework as Framework$1 } from "@codespark/framework";
+import DOMPurify from "dompurify";
+import { marked } from "marked";
+
+//#region src/loaders/types.ts
+let LoaderType = /* @__PURE__ */ function(LoaderType$1) {
+	LoaderType$1["ESModule"] = "esmodule";
+	LoaderType$1["Style"] = "style";
+	LoaderType$1["Script"] = "script";
+	LoaderType$1["Asset"] = "asset";
+	return LoaderType$1;
+}({});
+
+//#endregion
+//#region src/loaders/markdown-loader.ts
+var MarkdownLoader = class {
+	name = "markdown-loader";
+	test = /\.md$/;
+	transform(source) {
+		const html = DOMPurify.sanitize(marked.parse(source, { async: false }));
+		return {
+			type: LoaderType.Asset,
+			content: html
+		};
+	}
+};
+
+//#endregion
+//#region src/markdown/analyze.ts
+const LOADERS = [new MarkdownLoader()];
+function matchLoader(path) {
+	return LOADERS.find((l) => l.test.test(path)) ?? null;
+}
+function processFile(path, files, outputs = /* @__PURE__ */ new Map(), visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(path)) return;
+	visited.add(path);
+	const source = files[path];
+	if (source === void 0) return;
+	const loader = matchLoader(path);
+	if (!loader) return;
+	const output = loader.transform(source);
+	const result = {
+		path,
+		content: output.content
+	};
+	outputs.get(output.type).push(result);
+}
+function analyze(entry, files) {
+	const outputs = /* @__PURE__ */ new Map();
+	outputs.set(LoaderType.ESModule, []);
+	outputs.set(LoaderType.Style, []);
+	outputs.set(LoaderType.Script, []);
+	outputs.set(LoaderType.Asset, []);
+	processFile(entry, files, outputs);
+	return outputs;
+}
+
+//#endregion
+//#region src/markdown/index.ts
+var Framework = class extends Framework$1 {
+	name = "markdown";
+	imports = {};
+	outputs = /* @__PURE__ */ new Map();
+	analyze(entry, files) {
+		this.outputs = analyze(entry, files);
+	}
+	compile() {
+		const assets = this.getOutput(LoaderType.Asset);
+		return this.createBuilder().setHTML(JSON.stringify(assets.map(({ content }) => content).join(""))).done();
+	}
+};
+const markdown = new Framework();
+
+//#endregion
+export { Framework, markdown };

package/dist/react.d.ts

@@ -0,0 +1,59 @@
+import { Framework as Framework$1 } from "@codespark/framework";
+import MagicString from "magic-string";
+
+//#region src/loaders/types.d.ts
+declare enum LoaderType {
+  ESModule = "esmodule",
+  Style = "style",
+  Script = "script",
+  Asset = "asset",
+}
+interface BaseLoaderOutput<T extends LoaderType> {
+  type: T;
+  content: string;
+}
+interface ESModuleLoaderOutput extends BaseLoaderOutput<LoaderType.ESModule> {
+  dependencies: Record<string, string>;
+  externals: {
+    name: string;
+    imported: string[];
+  }[];
+}
+interface StyleLoaderOutput extends BaseLoaderOutput<LoaderType.Style> {
+  imports: string[];
+  href?: string;
+  attributes?: Record<string, string>;
+}
+interface ScriptLoaderOutput extends BaseLoaderOutput<LoaderType.Script> {
+  src?: string;
+  attributes?: Record<string, string>;
+}
+type AssetLoaderOutput = BaseLoaderOutput<LoaderType.Asset>;
+type LoaderOutput<T extends LoaderType> = Extract<ESModuleLoaderOutput | StyleLoaderOutput | ScriptLoaderOutput | AssetLoaderOutput, {
+  type: T;
+}>;
+//#endregion
+//#region src/registry.d.ts
+type Output<T extends LoaderType = LoaderType> = Omit<LoaderOutput<T>, 'type'> & {
+  path: string;
+};
+type Outputs = Map<LoaderType, Output[]>;
+//#endregion
+//#region src/react/index.d.ts
+declare class Framework extends Framework$1 {
+  readonly name = "react";
+  readonly imports: {
+    react: string;
+    'react/jsx-runtime': string;
+    'react-dom/client': string;
+  };
+  outputs: Outputs;
+  private blobUrlMap;
+  analyze(entry: string, files: Record<string, string>): void;
+  compile(): any;
+  private transformModulesToBlob;
+  private transformCodeWithBlobUrls;
+}
+declare const react: Framework;
+//#endregion
+export { Framework, react };