@kirana-style/compiler-browser 0.0.0 → 0.3.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kirana-style/compiler-browser",
-  "version": "0.0.0",
-  "description": "Placeholder: the Kirana engine in a browser page, WebAssembly with an in-memory project, ships with Kirana. https://kirana.style/docs/project/ecosystem",
+  "version": "0.3.5",
+  "description": "The Kirana engine in a browser: WebAssembly with an in-memory project, for playgrounds and editors on the web.",
   "license": "MIT",
   "author": "The Kirana authors",
   "homepage": "https://kirana.style",
@@ -10,11 +10,38 @@
     "url": "git+https://github.com/kirana-style/kirana.git",
     "directory": "packages/kirana/npm/compiler-browser"
   },
+  "bugs": {
+    "url": "https://github.com/kirana-style/kirana/issues"
+  },
   "type": "module",
+  "sideEffects": false,
   "exports": {
-    ".": "./index.js",
-    "./runtime": "./index.js",
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./compiler.js"
+    },
+    "./runtime": {
+      "types": "./types/runtime.d.ts",
+      "default": "./runtime.js"
+    },
     "./package.json": "./package.json"
   },
-  "files": ["index.js", "README.md", "LICENSE"]
+  "files": [
+    "compiler.js",
+    "runtime.js",
+    "wasi-worker-browser.mjs",
+    "kirana.wasm32-wasi.wasm",
+    "*.js",
+    "types",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@kirana-style/core": "0.3.5"
+  },
+  "peerDependenciesMeta": {
+    "@kirana-style/core": {
+      "optional": true
+    }
+  }
 }

package/runtime.js

@@ -0,0 +1,142 @@
+// ../core/src/internal.ts
+/**
+* The private runtime (KRN-DYN-005, D-018). The compiler imports it; applications never do.
+*
+* A compiled handle is a class string, or `{ c, v }` when it carries bridged custom properties.
+* Kirana class names are `{prefix}{key}_{value}`: merging keeps the last class per key, a
+* `{prefix}{key}_` tombstone removes one key, and `{prefix}{property}*_` removes every key of a
+* property, and `{prefix}{shorthand}/{codes}{scope}_` unfolds a shorthand atom into longhands.
+* Classes without the prefix pass through in order.
+*/
+/** A base-62 property code (`0-9a-zA-Z`) for an index, as class names spell them (D-037). */
+const code = (index) => (index > 61 ? code(index / 62 | 0) : "") + String.fromCharCode((index %= 62) < 10 ? index + 48 : index < 36 ? index + 87 : index + 29);
+/**
+* `key` is `base`, or — for every condition set — `base` plus `-` and a condition segment: a
+* 4-character hash, or a 1–2 character code in dense names. A 3-character segment is a target, and
+* a second `-` starts another segment, so neither is a condition of `base`.
+*/
+const scoped = (key, base, every) => key === base || every && key.startsWith(base + "-") && !/-|^...$/.test(key.slice(base.length + 1));
+function runtime(prefix, attribute) {
+	const add = (merged, handle) => {
+		if (!handle) return;
+		if (Array.isArray(handle)) {
+			for (const inner of handle) add(merged, inner);
+			return;
+		}
+		if (typeof handle === "object") {
+			Object.assign(merged.v, handle.v);
+			handle = handle.c;
+		}
+		let classes = merged.c;
+		for (const token of handle.split(" ")) {
+			if (!token) continue;
+			const end = token.lastIndexOf("_");
+			if (!token.startsWith(prefix) || end < 0) {
+				classes.set(" " + token, token);
+				continue;
+			}
+			const key = token.slice(prefix.length, end);
+			const head = key.split("-")[0];
+			if (!head[2]) {
+				let index = 0;
+				for (const digit of head) {
+					const unit = digit.charCodeAt(0);
+					index = index * 62 + unit - (unit > 96 ? 87 : unit > 64 ? 29 : 48);
+				}
+				let size = index < 45 ? index % 5 ? 0 : 4 : index < 111 && !((index - 45) % 3) ? 2 : 0;
+				while (size) classes.delete(code(index + size--) + key.slice(head.length));
+			}
+			const slash = key.indexOf("/");
+			if (slash > 0) {
+				const every = key.endsWith("*");
+				const tail = key.slice(slash + 1, every ? -1 : void 0);
+				const dash = tail.indexOf("-") >>> 0;
+				const shorthand = key.slice(0, slash);
+				const earlier = classes;
+				merged.c = classes = /* @__PURE__ */ new Map();
+				for (const [existing, atom] of earlier) if (!atom.endsWith("_") && scoped(existing, shorthand + tail.slice(dash), every)) {
+					const rest = existing.slice(shorthand.length);
+					for (let kept of tail.slice(0, dash).split(".")) if (classes.delete(kept += rest) || !earlier.has(kept)) classes.set(kept, prefix + kept + atom.slice(atom.lastIndexOf("_")));
+				} else classes.set(existing, atom);
+			} else if (key.endsWith("*")) {
+				for (const existing of classes.keys()) if (scoped(existing, key.slice(0, -1), true) && !existing.endsWith("*")) classes.delete(existing);
+			}
+			classes.delete(key);
+			classes.set(key, token);
+		}
+	};
+	const merge = (handles) => {
+		const merged = {
+			c: /* @__PURE__ */ new Map(),
+			v: {}
+		};
+		add(merged, handles);
+		return merged;
+	};
+	/** Merges handles into one handle. */
+	const cx = (...handles) => {
+		const merged = merge(handles);
+		const c = [...merged.c.values()].join(" ");
+		return Object.keys(merged.v).length ? {
+			c,
+			v: merged.v
+		} : c;
+	};
+	/**
+	* Props already merged, by their inputs' text. An element renders the same few combinations over
+	* and over (a table cell with no `sx` of its own is one), so each is merged once and shared, with
+	* its `className`, by every element that renders it; past a bound the cache starts over, so text
+	* built at runtime cannot grow it without end.
+	*/
+	const settled = /* @__PURE__ */ new Map();
+	/** The props for a host element: foreign classes first, then handles; bridged variables last. */
+	const sx = (handles, classNames, styles) => {
+		const key = JSON.stringify([
+			handles,
+			classNames,
+			styles
+		]);
+		let props = settled.get(key);
+		if (!props) {
+			const merged = merge([classNames.filter((name) => typeof name === "string"), handles]);
+			const className = [...merged.c.values()].filter((token) => !token.endsWith("_")).join(" ");
+			const style = Object.assign({}, ...styles.filter((value) => value && typeof value === "object"), merged.v);
+			props = {
+				...className ? { [attribute]: className } : {},
+				...Object.keys(style).length ? { style } : {}
+			};
+			if (settled.size > 4095) settled.clear();
+			settled.set(key, props);
+		}
+		return props.style ? {
+			...props,
+			style: { ...props.style }
+		} : { ...props };
+	};
+	/** A bridged value: `null` and `undefined` become `initial` so the declaration falls back. */
+	const b = (c, variable, value) => ({
+		c,
+		v: { [variable]: value == null ? "initial" : String(value) }
+	});
+	/** A recipe resolved at runtime from its compiled table. */
+	const recipe = (table) => (options) => {
+		const pick = (group) => {
+			const value = options?.[group] ?? table.d[group];
+			return value == null ? void 0 : String(value);
+		};
+		const slots = (table.s ?? [""]).map((_, index) => {
+			const parts = [table.b[index]];
+			for (const group in table.v) parts.push(table.v[group][pick(group)]?.[index]);
+			for (const [selection, handles] of table.c) if (Object.keys(selection).every((group) => pick(group) === selection[group])) parts.push(handles[index]);
+			return cx(parts);
+		});
+		return table.s ? Object.fromEntries(table.s.map((name, index) => [name, slots[index]])) : slots[0];
+	};
+	return {
+		cx,
+		sx,
+		b,
+		recipe
+	};
+}
+export { runtime };

package/types/index.d.ts

@@ -0,0 +1,21 @@
+import type { Project, ProjectOptions } from "./project.js"
+
+export type {
+  Diagnostic,
+  Position,
+  Project,
+  ProjectOptions,
+  Transformed,
+} from "./project.js"
+export { positionOf } from "./project.js"
+import type { KiranaConfig } from "@kirana-style/core/config"
+/** The engine's JSON for a configuration (KRN-INT-001). */
+export declare function configJson(
+  root: string,
+  config: KiranaConfig,
+  inline: KiranaConfig,
+  options?: { jsx?: "preact" | "solid" | "qwik" }
+): string
+
+/** Opens a project in the engine's in-memory file system. */
+export declare function createProject(options?: ProjectOptions): Project

package/types/project.d.ts

@@ -0,0 +1,95 @@
+import { KiranaConfig } from "@kirana-style/core/config";
+/** The file system calls a project makes: memfs's volume in a browser, `node:fs` in the tests. */
+export type Volume = {
+  mkdirSync: (path: string, options: {
+    recursive: true;
+  }) => unknown;
+  writeFileSync: (path: string, data: string) => void;
+  rmSync: (path: string, options: {
+    force: true;
+  }) => void;
+};
+/** The engine's compilation session, as the binding gives it. */
+export type Session = {
+  transform: (id: string, code: string) => {
+    code?: string;
+    map?: string;
+    diagnostics: string;
+    cssChanged: boolean;
+    dependencies: string[];
+  };
+  stylesheet: (minify: boolean) => string;
+  diagnostics: () => string;
+  invalidate: (id: string) => string[];
+  remove: (id: string) => boolean;
+};
+/** What `openProject` needs from the engine. */
+export type Engine = {
+  Compiler: new (configJson: string) => Session;
+  __volume: Volume;
+};
+/** A place in a file: line and column from 1, the column in UTF-16 code units as editors count. */
+export type Position = {
+  line: number;
+  column: number;
+};
+/** A diagnostic, with its span as positions in the file it names as well as the engine's bytes. */
+export type Diagnostic = {
+  code: string;
+  name: string;
+  severity: "info" | "warning" | "error";
+  /** The file, relative to the project root; empty for the project as a whole. */
+  file: string;
+  message: string;
+  help: string[];
+  /** UTF-8 byte offsets, as the engine counts. */
+  span: {
+    start: number;
+    end: number;
+  };
+  /** Where the span starts and ends; undefined when the diagnostic names no file of the project. */
+  start?: Position;
+  end?: Position;
+};
+export type Transformed = {
+  /** The rewritten module, still TypeScript and JSX; undefined when the module has no styles. */
+  code?: string;
+  map?: string;
+  diagnostics: Diagnostic[];
+  /** Whether the stylesheet changed. */
+  cssChanged: boolean;
+  /** Files the module read while it compiled, relative to the root. */
+  dependencies: string[];
+};
+export type ProjectOptions = {
+  /** The configuration, already evaluated: what `kirana.config.ts`'s default export holds. */
+  config?: KiranaConfig;
+  /** Where the project lives in the engine's file system. Default `/app`. */
+  root?: string;
+  /** Files to write first, by path relative to the root. */
+  files?: Readonly<Record<string, string>>;
+};
+export type Project = {
+  readonly root: string;
+  /** The configuration as the engine received it. */
+  readonly configJson: string;
+  /**
+   * Writes a file (relative to the root) and invalidates what read it: the files returned, relative
+   * to the root, need transforming again.
+   */
+  write: (file: string, code: string) => string[];
+  /** Removes a file, and what it contributed to the stylesheet. */
+  remove: (file: string) => void;
+  /** Compiles a file written before. */
+  transform: (file: string) => Transformed;
+  /** The stylesheet of every module transformed so far. */
+  stylesheet: (minify?: boolean) => string;
+  /** Diagnostics about the project as a whole (token and relation checks). */
+  diagnostics: () => Diagnostic[];
+  /** The files written, relative to the root, in the order they were first written. */
+  files: () => string[];
+};
+/** The position of a UTF-8 byte offset in `source`. */
+export declare function positionOf(source: string, offset: number): Position;
+/** Opens a project on `engine`: the configuration becomes the engine's JSON, the files are written. */
+export declare function openProject(engine: Engine, { config, root, files }?: ProjectOptions): Project;

package/types/runtime.d.ts

@@ -0,0 +1 @@
+export { runtime } from "@kirana-style/core/internal"

package/wasi-worker-browser.mjs

@@ -0,0 +1,44 @@
+import { a as instantiateNapiModuleSync, c as WASI, l as asyncWork, o as createFsProxy, r as MessageHandler, t as import_lib, u as threadsafeFunction } from "./fs.js";
+// ../../dist-packages/stage/compiler-browser/engine/wasi-worker-browser.mjs
+const fs = createFsProxy(import_lib);
+const handler = new MessageHandler({ onLoad({ wasmModule, wasmMemory }) {
+	const wasi = new WASI({
+		fs,
+		preopens: { "/": "/" },
+		print: function() {
+			console.log.apply(console, arguments);
+		},
+		printErr: function() {
+			console.error.apply(console, arguments);
+		}
+	});
+	return instantiateNapiModuleSync(wasmModule, {
+		childThread: true,
+		wasi,
+		plugins: [asyncWork, threadsafeFunction],
+		overwriteImports(importObject) {
+			importObject.env = {
+				...importObject.env,
+				...importObject.napi,
+				...importObject.emnapi,
+				memory: wasmMemory
+			};
+		}
+	});
+} });
+let __addonCrashFlag;
+const __beforeReportError = handler.beforeReportError;
+handler.beforeReportError = function(...args) {
+	if (__addonCrashFlag !== void 0) try {
+		Atomics.store(__addonCrashFlag, 0, 1);
+	} catch {}
+	return __beforeReportError.apply(this, args);
+};
+globalThis.onmessage = function(e) {
+	const data = e && e.data;
+	if (data && data.__napiRsAddonCrashFlag instanceof Int32Array) {
+		__addonCrashFlag = data.__napiRsAddonCrashFlag;
+		return;
+	}
+	handler.handle(e);
+};

package/README.md

@@ -1,7 +0,0 @@
-# @kirana-style/compiler-browser
-
-A placeholder holding the name for the Kirana engine in a browser page: the WebAssembly engine with
-an in-memory project, for playgrounds and editors on the web. It will release together with Kirana.
-Install `@kirana-style/compiler-browser@latest`.
-
-Documentation: https://kirana.style/docs/project/ecosystem · Source: https://github.com/kirana-style/kirana

package/index.js

@@ -1,5 +0,0 @@
-// A placeholder that holds the name on npm until the first release. It fails loudly rather than
-// doing nothing.
-throw new Error(
-  "@kirana-style/compiler-browser@0.0.0 is a placeholder. Install @kirana-style/compiler-browser@latest."
-)