@kodaicoder/shadcn-svelte-daisyui-adapter 0.0.0-stage → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## 0.2.0
+
+The CLI no longer creates `daisyui-adapter.overrides.css` or writes its `@import` line. Overrides are opt-in: the user adds the file and the import, and the README's Overrides section describes how. An existing file and import are left untouched, so a project that installed 0.1.0 keeps both.
+
+A re-run applies the change to a 0.1.0 project, and the header comment updates to 0.2.0.
+
+## 0.1.0
+
+First release. The CLI writes the header comment, the `@plugin "@kodaicoder/shadcn-svelte-daisyui-adapter";` line, the `daisyui-adapter.overrides.css` file and its import, and the 32 bindings per block; the plugin emits `--daisy-color-*` and `--daisy-radius` from `src/daisyui-theme.css` at build time.
+
+The first install is the only required run. A later `shadcn-svelte init` keeps the header comment and the override import, wipes the bindings, and the next `init` restores them.
+
+A change to the mapping table or to the shape the plugin emits is a minor bump, and it requires a re-run. The header comment names the version that wrote the stylesheet, so a project can tell which one it holds.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nutchapon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,110 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @kodaicoder/shadcn-svelte-daisyui-adapter
+
+Generate a shadcn-svelte token set from a daisyUI v5 theme, at build time, with no daisyUI runtime dependency.
+
+The CLI reads your stylesheet and your `src/daisyui-theme.css`, then rewrites each `:root` and `.dark` block so every shadcn token reads a daisyUI value, with the value that was already in the file as the fallback. It also writes the `@plugin` line and the chart ramp. The plugin then emits `--daisy-color-*` and `--daisy-radius` from the theme while Tailwind builds, so a theme change takes one rebuild and no re-run.
+
+This package is not affiliated with shadcn-svelte or daisyUI. Both names are used only to say what it reads and what it writes.
+
+## Prerequisites
+
+- A SvelteKit project with `shadcn-svelte` set up through step 4 of its guide.
+- `components.json` at the project root, with `tailwind.css` pointing at the project's global stylesheet (`src/routes/layout.css` on SvelteKit 3, `src/app.css` on older projects). The CLI reads that path on every run and never hardcodes it.
+- That stylesheet imported by the root layout.
+- `src/daisyui-theme.css` holding one light and one dark block from the [daisyUI theme generator](https://daisyui.com/theme-generator/). Copy the blocks as they are, including the `@plugin "daisyui/theme"` prelude.
+
+## Usage
+
+```bash
+# 1. paste one light and one dark block from the theme generator
+#    into src/daisyui-theme.css
+
+# 2. shadcn-svelte, as its guide says
+pnpm dlx shadcn-svelte@latest init
+
+# 3. the adapter, at an exact version
+pnpm dlx @kodaicoder/shadcn-svelte-daisyui-adapter@0.2.0 init
+
+# 4. the gate
+pnpm build
+```
+
+The CLI adds the package as a devDependency at its own version, because the `@plugin` specifier resolves through `node_modules` at build time. Run it from the project root.
+
+## What the CLI prints
+
+```
+[daisyui-adapter] theme ok: light + dark
+[daisyui-adapter] wrote src/routes/layout.css
+[daisyui-adapter] 32 light, 32 dark
+[daisyui-adapter] installed @kodaicoder/shadcn-svelte-daisyui-adapter@0.2.0
+```
+
+The declaration count comes back from the file it wrote, so a stylesheet missing a row the adapter expects shows a number below 32. A second run prints `already installed` instead of installing again. A run on a stylesheet from 0.1.0 prints `upgrading 0.1.0 -> 0.2.0` before the rest.
+
+A missing theme file is a warning, not a failure. The CLI prints `E1`, writes the bindings with your own values as fallbacks, and the build renders the project's palette. A malformed theme file exits non-zero with `E2` or `E3`, because a wrong pair would render wrong colours silently.
+
+## The header comment
+
+The first line of the stylesheet is the version marker:
+
+```
+/* @kodaicoder/shadcn-svelte-daisyui-adapter 0.2.0 | re-run `pnpm dlx @kodaicoder/shadcn-svelte-daisyui-adapter@0.2.0 init` after `shadcn-svelte init` */
+```
+
+`shadcn-svelte init` keeps the header comment, wipes the bindings, and the next adapter run restores them. If the project has an override import, that import is kept too, but the CLI does not create it. Re-run when:
+
+- `shadcn-svelte init` or a large `add` changed the stylesheet;
+- you moved to a newer CLI and want the header to name it;
+- the changelog says the mapping table or the emitted shape changed.
+
+The CLI refuses to run when the header names a newer version than the CLI. It prints `E4`, exits non-zero and writes nothing, because an older CLI would undo bindings a newer one wrote. Run the version the header names, or upgrade the CLI.
+
+## Overrides (optional)
+
+The CLI does not create `daisyui-adapter.overrides.css` and does not write its import. Overrides are opt-in: you add both yourself.
+
+To use overrides, create `daisyui-adapter.overrides.css` beside the global stylesheet, then add this line after the other `@import` lines and before the generated `:root` and `.dark` blocks:
+
+```css
+@import "./daisyui-adapter.overrides.css";
+```
+
+The CLI never writes or deletes the file. If the project installed 0.1.0, the file and the import already exist. Keep them if you use them, or delete both if you do not.
+
+The import comes before the generated blocks, so a plain `:root` there loses on source order. Raise the specificity and keep the light block out of dark mode. Use `html:not(.dark)` for light and `html.dark` for dark:
+
+```css
+html:not(.dark) {
+	--daisy-derived-chart-1: oklch(0.62 0.08 250);
+}
+
+html.dark {
+	--daisy-derived-chart-1: oklch(0.72 0.08 250);
+}
+```
+
+Both selectors beat the generated `:root` and `.dark`, and the light one does not leak into dark. Write the pair when you need both schemes.
+
+## Version policy
+
+The header records one exact version, and that number is what a project holds. A patch release fixes the CLI or the parser without moving a key or changing a shape, and does not need a re-run. A change to the mapping table, to a token's shape or to what the plugin emits is a minor bump, and it requires a re-run. The changelog names each one.
+
+## Checking the result
+
+`pnpm build` is the gate. The plugin reads `src/daisyui-theme.css` while Tailwind builds, so a malformed theme block fails there. With the theme removed, the build still passes and the page renders the pre-adapter palette.
+
+## Testing a tarball before publish
+
+`pnpm pack` writes `kodaicoder-shadcn-svelte-daisyui-adapter-0.2.0.tgz`. Set `DAISYUI_ADAPTER_INSTALL_SPEC` to that file and the CLI installs it instead of the registry copy. Pack from the package directory, then run the CLI from the app's root:
+
+```bash
+# in packages/daisyui-adapter, writing into the app's root
+pnpm pack --pack-destination <app>
+
+# in the app's root
+DAISYUI_ADAPTER_INSTALL_SPEC=./kodaicoder-shadcn-svelte-daisyui-adapter-0.2.0.tgz \
+  node <repo>/packages/daisyui-adapter/cli/init.mjs
+```
+
+The CLI prints `installed ./kodaicoder-shadcn-svelte-daisyui-adapter-0.2.0.tgz`. Without the variable it installs `@kodaicoder/shadcn-svelte-daisyui-adapter@0.2.0` from the registry.

package/cli/init.mjs

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+// The adapter CLI. It reads components.json and the stylesheet, validates the theme, then writes the
+// header comment, the plugin line, the bindings for both blocks, and the five chart values. Re-running
+// it is byte-identical. The override file and its import are the project's to add; this CLI never
+// creates, deletes or rewrites either one.
+//
+// It never writes a raw `--color-*` name (ticket 14: that forms a cycle with `@theme inline`, and
+// the fallback is then silently ignored), and it writes the chart ramp itself rather than leaving it
+// to the plugin, because `addBase` lands in `@layer base` and the project's unlayered `:root` wins
+// (ticket 13).
+//
+// Name, version and the bin come from package.json, so the header, the plugin specifier and the
+// self-install spec cannot drift from each other. The header is replaced, not prepended: a project
+// that ran an older CLI must end up with exactly one line naming its version.
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { BINDING_KEYS, SINGLE, mixValue } from '../dist/map.mjs';
+import { chartTokens, solveScheme } from '../dist/ramp.mjs';
+import { parseTheme, themePath } from '../dist/index.mjs';
+
+const manifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const PKG = manifest.name;
+const VERSION = manifest.version;
+const BIN = Object.keys(manifest.bin)[0];
+const HEADER = `/* ${PKG} ${VERSION} | re-run \`pnpm dlx ${PKG}@${VERSION} init\` after \`shadcn-svelte init\` */`;
+const HEADER_PATTERN = /^\/\* (\S+) (\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?) \| re-run [^\n]*\*\/\r?\n?/;
+const OVERRIDE = 'daisyui-adapter.overrides.css';
+const BORDER_ENTRY = '--default-border-width: var(--daisy-border, 1px);';
+const PLUGIN = `@plugin "${PKG}";`;
+const PNPM = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
+
+const colorVar = (source) => `--daisy-color-${source}`;
+const targetVar = (key) => (SINGLE[key].scalar ? '--daisy-radius' : colorVar(SINGLE[key].source));
+
+const compareVersions = (a, b) => {
+	const split = (value) => {
+		const [core, pre = ''] = value.split('-');
+		return { nums: core.split('.').map(Number), pre: pre ? pre.split('.') : [] };
+	};
+	const left = split(a);
+	const right = split(b);
+	for (let i = 0; i < 3; i++) {
+		if (left.nums[i] !== right.nums[i]) return Math.sign(left.nums[i] - right.nums[i]);
+	}
+	if (left.pre.length === 0 || right.pre.length === 0) {
+		return Math.sign(right.pre.length - left.pre.length);
+	}
+	for (let i = 0; i < Math.max(left.pre.length, right.pre.length); i++) {
+		if (left.pre[i] === right.pre[i]) continue;
+		if (left.pre[i] === undefined) return -1;
+		if (right.pre[i] === undefined) return 1;
+		const [x, y] = [Number(left.pre[i]), Number(right.pre[i])];
+		if (Number.isNaN(x) || Number.isNaN(y)) return left.pre[i] < right.pre[i] ? -1 : 1;
+		return Math.sign(x - y);
+	}
+	return 0;
+};
+
+// A value this CLI wrote on an earlier run keeps its fallback in the second var() argument. Reading
+// it back out is what makes a re-run byte-identical instead of nesting var() inside var().
+const unwrapFallback = (value) => {
+	const match = /^var\(--[\w-]+,\s*([\s\S]*)\)$/.exec(value.trim());
+	return match ? match[1].trim() : value.trim();
+};
+
+const blockBounds = (source, selector) => {
+	const pattern = new RegExp(`^${selector.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\{`, 'm');
+	const match = pattern.exec(source);
+	if (!match) return null;
+	const open = source.indexOf('{', match.index);
+	let depth = 0;
+	for (let i = open; i < source.length; i++) {
+		if (source[i] === '{') depth++;
+		else if (source[i] === '}') {
+			depth--;
+			if (depth === 0) return { open, close: i };
+		}
+	}
+	return null;
+};
+
+const declarations = (body) =>
+	[...body.matchAll(/^\s*(--[\w-]+)\s*:\s*([\s\S]*?);\s*$/gm)].map((m) => ({
+		prop: m[1],
+		value: m[2].trim()
+	}));
+
+const readBlock = (source, selector, where) => {
+	const bounds = blockBounds(source, selector);
+	if (!bounds) throw new Error(`[daisyui-adapter] ${where} has no ${selector} block`);
+	return declarations(source.slice(bounds.open + 1, bounds.close));
+};
+
+// Foreign declarations stay where they are and in their order. Every key the map owns is rewritten
+// from its fallback, so a key the plugin never emits still resolves. Derived keys are dropped and
+// re-emitted rather than accumulated. Without a theme the chart rows are left as the project has
+// them, because a ramp cannot be solved from a file that is not there.
+//
+// A chart row takes a mix key's shape: the project's own row in the fallback slot, the ramp behind a
+// helper. A row that already holds a ramp is not a project value, and copying one into its own slot
+// is the one thing that must never happen. That row is left alone, because the value it replaced is
+// only in the project's history, and a second solve would hide that it was lost.
+const isRamp = (value) => value.includes('oklch(from var(--daisy-color-primary)');
+
+let rampWarned = false;
+const warnBareRamp = (key) => {
+	if (rampWarned) return;
+	rampWarned = true;
+	console.warn(
+		`[daisyui-adapter] --${key} holds a ramp written by an older CLI with no fallback. Its original ` +
+			`value is gone; restore the stylesheet from version control, or set --daisyui-derived-${key} ` +
+			`in the optional ${OVERRIDE} file, which the README's Overrides section describes.`
+	);
+};
+
+const rebuild = (current, fallback, scheme) => {
+	const lines = [];
+	for (const { prop, value } of current) {
+		if (prop.startsWith('--daisy-derived-')) continue;
+		const key = prop.slice(2);
+		if (BINDING_KEYS.includes(key) || key.startsWith('chart-')) continue;
+		lines.push(`\t${prop}: ${value};`);
+	}
+	for (const key of BINDING_KEYS) {
+		const old = unwrapFallback(
+			current.find((d) => d.prop === `--${key}`)?.value ?? fallback[`--${key}`] ?? ''
+		);
+		if (SINGLE[key]) {
+			lines.push(`\t--${key}: var(${targetVar(key)}, ${old});`);
+		} else {
+			lines.push(`\t--${key}: var(--daisy-derived-${key}, ${old});`);
+			lines.push(`\t--daisy-derived-${key}: ${mixValue(key, colorVar)};`);
+		}
+	}
+	if (scheme) {
+		for (const [i, value] of chartTokens(scheme).entries()) {
+			const key = `chart-${i + 1}`;
+			const old = unwrapFallback(current.find((d) => d.prop === `--${key}`)?.value ?? '');
+			if (old && !isRamp(old)) {
+				lines.push(`\t--${key}: var(--daisy-derived-${key}, ${old});`);
+				lines.push(`\t--daisy-derived-${key}: ${value};`);
+			} else if (old) {
+				warnBareRamp(key);
+				lines.push(`\t--${key}: ${old};`);
+			} else {
+				lines.push(`\t--${key}: ${value};`);
+			}
+		}
+	} else {
+		for (const { prop, value } of current)
+			if (prop.startsWith('--chart-')) lines.push(`\t${prop}: ${value};`);
+	}
+	return lines.join('\n');
+};
+
+const replaceBlock = (source, selector, body) => {
+	const bounds = blockBounds(source, selector);
+	if (!bounds) return null;
+	return `${source.slice(0, bounds.open + 1)}\n${body}\n${source.slice(bounds.close)}`;
+};
+
+const insertAfterLastImport = (source, line) => {
+	if (source.includes(line)) return source;
+	const lines = source.split('\n');
+	const last = lines.reduce((found, text, i) => (text.startsWith('@import ') ? i : found), -1);
+	if (last === -1) throw new Error('[daisyui-adapter] the stylesheet has no @import line');
+	lines.splice(last + 1, 0, line);
+	return lines.join('\n');
+};
+
+// The one entry the bindings cannot carry. Tailwind reads a bare border width from
+// `--default-border-width`, and `--daisy-border` is emitted by the plugin from the theme's --border,
+// so the 1px here is only the fallback for a project with no theme (ticket 11).
+const insertThemeEntries = (source) => {
+	if (source.includes('--default-border-width')) return source;
+	const bounds = blockBounds(source, '@theme inline');
+	if (!bounds) {
+		console.warn('[daisyui-adapter] no @theme inline block, so --border will not reach border');
+		return source;
+	}
+	return `${source.slice(0, bounds.close)}\t${BORDER_ENTRY}\n${source.slice(bounds.close)}`;
+};
+
+const installLine = (spec) => {
+	const local = resolve('node_modules', ...PKG.split('/'), 'package.json');
+	if (existsSync(local)) {
+		try {
+			if (JSON.parse(readFileSync(local, 'utf8')).version === VERSION) {
+				return `already installed ${PKG} ${VERSION}`;
+			}
+		} catch {}
+	}
+	try {
+		// One command string: an argument array with a shell makes Windows Node warn on every run
+		// (DEP0190), and `pnpm.cmd` cannot be executed without a shell there.
+		execSync(`${PNPM} add -D "${spec}"`, { stdio: 'inherit' });
+	} catch {
+		throw new Error(
+			`[daisyui-adapter] could not install ${spec}. Run \`pnpm add -D ${spec}\` yourself, then \`pnpm exec ${BIN} init\`.`
+		);
+	}
+	return `installed ${spec}`;
+};
+
+const main = () => {
+	const componentsPath = resolve('components.json');
+	if (!existsSync(componentsPath)) {
+		throw new Error('[daisyui-adapter] no components.json. Run `shadcn-svelte init` first.');
+	}
+	const components = JSON.parse(readFileSync(componentsPath, 'utf8'));
+	if (!components.tailwind?.css) {
+		throw new Error('[daisyui-adapter] components.json has no tailwind.css path');
+	}
+	const cssPath = resolve(components.tailwind.css);
+	const where = components.tailwind.css;
+	let css = readFileSync(cssPath, 'utf8');
+
+	// An older CLI cannot reproduce a newer version's bindings, so it would quietly undo them. The
+	// stylesheet still names the version that wrote it, which is the only record a project keeps.
+	const header = HEADER_PATTERN.exec(css);
+	const headerVersion = header?.[2] ?? null;
+	if (headerVersion && compareVersions(headerVersion, VERSION) > 0) {
+		throw new Error(
+			`[daisyui-adapter] E4 ${where} was written by ${PKG} ${headerVersion}, but this CLI is ${VERSION}. ` +
+				`Run \`pnpm dlx ${PKG}@${headerVersion} init\` or upgrade the CLI.`
+		);
+	}
+	if (headerVersion) css = css.replace(HEADER_PATTERN, '');
+	if (headerVersion && compareVersions(headerVersion, VERSION) < 0) {
+		console.log(`[daisyui-adapter] upgrading ${headerVersion} -> ${VERSION}`);
+	}
+
+	// E1: absence warns at init and continues, because a later paste fixes it. E2 and E3 throw,
+	// because a malformed pair would render wrong colours silently.
+	const path = themePath();
+	let themes = null;
+	if (!existsSync(path)) {
+		console.warn(
+			`[daisyui-adapter] E1 Cannot read the daisyUI theme file at ${path}. ` +
+				`Put one light and one dark theme block from https://daisyui.com/theme-generator/ ` +
+				`in that file, then re-run the build. The CLI-written fallbacks render until then.`
+		);
+	} else {
+		themes = parseTheme(readFileSync(path, 'utf8'), path);
+	}
+
+	const stockLight = Object.fromEntries(
+		readBlock(css, ':root', where).map((d) => [d.prop, d.value])
+	);
+	const chart = themes
+		? { light: solveScheme(themes.light), dark: solveScheme(themes.dark) }
+		: null;
+
+	css = replaceBlock(
+		css,
+		'.dark',
+		rebuild(readBlock(css, '.dark', where), stockLight, chart?.dark ?? null)
+	);
+	if (!css) throw new Error(`[daisyui-adapter] ${where} has no .dark block`);
+	css = replaceBlock(
+		css,
+		':root',
+		rebuild(readBlock(css, ':root', where), stockLight, chart?.light ?? null)
+	);
+	if (!css) throw new Error(`[daisyui-adapter] ${where} has no :root block`);
+
+	if (themes) {
+		css = insertAfterLastImport(css, PLUGIN);
+		css = insertThemeEntries(css);
+	}
+	css = `${HEADER}\n${css}`;
+
+	writeFileSync(cssPath, css);
+
+	// Read back what was written: a block the CLI matched but could not fill has to show a count
+	// below 32 rather than a number from the data it meant to write.
+	const written = readFileSync(cssPath, 'utf8');
+	const count = (selector) =>
+		readBlock(written, selector, where).filter((d) => !d.prop.startsWith('--daisy-derived-'))
+			.length;
+	const lightCount = count(':root');
+	const darkCount = count('.dark');
+
+	if (themes) console.log('[daisyui-adapter] theme ok: light + dark');
+	console.log(`[daisyui-adapter] wrote ${where}`);
+	console.log(`[daisyui-adapter] ${lightCount} light, ${darkCount} dark`);
+
+	// The install is last, after the lines that describe what was written, so a failed install
+	// still tells the user the stylesheet is in place.
+	const spec = process.env.DAISYUI_ADAPTER_INSTALL_SPEC ?? `${PKG}@${VERSION}`;
+	console.log(`[daisyui-adapter] ${installLine(spec)}`);
+
+	if (chart) {
+		for (const scheme of ['light', 'dark']) {
+			const solved = chart[scheme];
+			console.log(
+				`[daisyui-adapter] ${scheme} chart L ${solved.lightness.map((l) => l.toFixed(4)).join(' ')} ` +
+					`min adjacent ${solved.minAdjacent.toFixed(3)}`
+			);
+		}
+	}
+};
+
+try {
+	main();
+} catch (error) {
+	console.error(String(error.message ?? error));
+	process.exitCode = 1;
+}

package/dist/index.mjs

@@ -0,0 +1,99 @@
+// The build-time half. It reads the user's theme and emits one namespace: `--daisy-color-<source>`
+// for the 20 daisyUI colours and `--daisy-radius` for the box rung. It never writes a shadcn token
+// name, so the CLI's bindings stay the only place a token is named.
+//
+// Two reasons it emits bindings rather than tokens. The plugin's `addBase` lands in `@layer base`,
+// and the project's unlayered `:root` beats any layered rule regardless of specificity (ticket 13).
+// And a `--primary: var(--color-primary, ...)` binding would form a cycle with `@theme inline`'s
+// `--color-primary: var(--primary)`, leaving the fallback silently ignored (ticket 14).
+//
+// Error text is ticket 02's contract: E1 is absent, E2 is a malformed pair, E3 is a malformed block.
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { COLOR_SOURCES } from './map.mjs';
+
+export const THEME_FILE = 'src/daisyui-theme.css';
+const GENERATOR = 'https://daisyui.com/theme-generator/';
+
+const blockPattern = /@plugin\s+["']daisyui\/theme["']\s*\{([\s\S]*?)\}/g;
+
+const E2 = (path, problem) =>
+	`[daisyui-adapter] ${path}: ${problem}. The file must hold exactly two v5 theme blocks, one ` +
+	`light and one dark. Generate both at ${GENERATOR}, paste them into that file, then re-run the build.`;
+
+const E3 = (path, label, problem) =>
+	`[daisyui-adapter] ${path}: theme "${label}" ${problem}. Replace that block with a complete ` +
+	`v5 block from ${GENERATOR}, then re-run the build.`;
+
+// Reads exactly one light block and one dark block. Order does not matter, `default` and
+// `prefersdark` are advisory, and `color-scheme` is the only light/dark marker.
+export const parseTheme = (text, path) => {
+	const blocks = [...text.matchAll(blockPattern)];
+	if (blocks.length !== 2) {
+		throw new Error(E2(path, `holds ${blocks.length} theme block(s)`));
+	}
+	const themes = {};
+	for (const block of blocks) {
+		const body = block[1];
+		const label = /name\s*:\s*["']([^"']+)["']/.exec(body)?.[1] ?? 'unnamed';
+		const scheme = /color-scheme\s*:\s*["']?(light|dark)["']?\s*;/.exec(body)?.[1];
+		if (!scheme) {
+			throw new Error(E3(path, label, 'has no color-scheme'));
+		}
+		if (/--[pr]-[a-z]/.test(body)) {
+			throw new Error(E3(path, label, 'uses daisyUI v4 variable names'));
+		}
+		if (themes[scheme]) {
+			throw new Error(E2(path, `holds two ${scheme} blocks`));
+		}
+		const vars = Object.fromEntries(
+			[...body.matchAll(/(--[a-z0-9-]+)\s*:\s*([^;]+);/g)].map((match) => [match[1], match[2].trim()])
+		);
+		for (const source of COLOR_SOURCES) {
+			if (!vars[`--color-${source}`]) {
+				throw new Error(E3(path, label, `is missing --color-${source}`));
+			}
+		}
+		if (!vars['--radius-box']) {
+			throw new Error(E3(path, label, 'is missing --radius-box'));
+		}
+		if (!vars['--border']) {
+			throw new Error(E3(path, label, 'is missing --border'));
+		}
+		themes[scheme] = vars;
+	}
+	return themes;
+};
+
+export const themePath = (cwd = process.cwd()) => resolve(cwd, THEME_FILE);
+
+// Absent is a state a later paste fixes, so the plugin emits nothing and the CLI-written fallbacks
+// decide what renders. Present but malformed is a defect that would render wrong colours silently.
+export const readTheme = (cwd = process.cwd()) => {
+	const path = themePath(cwd);
+	if (!existsSync(path)) return null;
+	return parseTheme(readFileSync(path, 'utf8'), path);
+};
+
+export const bindingsFor = (vars) => {
+	const out = {};
+	for (const source of COLOR_SOURCES) out[`--daisy-color-${source}`] = vars[`--color-${source}`];
+	out['--daisy-radius'] = vars['--radius-box'];
+	out['--daisy-border'] = vars['--border'];
+	return out;
+};
+
+export default {
+	handler({ addBase }) {
+		const themes = readTheme();
+		if (!themes) {
+			console.log(`[daisyui-adapter] no ${THEME_FILE}, emitting nothing; the CLI fallbacks render`);
+			return;
+		}
+		addBase({
+			':root': bindingsFor(themes.light),
+			'.dark': bindingsFor(themes.dark)
+		});
+	}
+};

package/dist/map.mjs

@@ -0,0 +1,83 @@
+// The one list that drives both the plugin and the CLI, so a renamed key cannot become an invalid
+// token. Ticket 09 (surfaces), 10 (sidebar rungs) and 11 (radius) settled the rows; ticket 12
+// settled that the chart ramp is computed, not assigned, so chart-1..5 are absent here on purpose
+// and are written by the CLI from ramp.mjs.
+
+export const COLOR_SOURCES = [
+	'base-100',
+	'base-200',
+	'base-300',
+	'base-content',
+	'primary',
+	'primary-content',
+	'secondary',
+	'secondary-content',
+	'accent',
+	'accent-content',
+	'neutral',
+	'neutral-content',
+	'info',
+	'info-content',
+	'success',
+	'success-content',
+	'warning',
+	'warning-content',
+	'error',
+	'error-content'
+];
+
+// A single row is a direct read of one daisyUI source. `radius` reads the CLI's scalar binding.
+export const SINGLE = {
+	background: { source: 'base-100' },
+	foreground: { source: 'base-content' },
+	card: { source: 'base-100' },
+	'card-foreground': { source: 'base-content' },
+	popover: { source: 'base-100' },
+	'popover-foreground': { source: 'base-content' },
+	primary: { source: 'primary' },
+	'primary-foreground': { source: 'primary-content' },
+	secondary: { source: 'base-200' },
+	'secondary-foreground': { source: 'base-content' },
+	muted: { source: 'base-200' },
+	'accent-foreground': { source: 'base-content' },
+	destructive: { source: 'error' },
+	ring: { source: 'primary' },
+	sidebar: { source: 'base-200' },
+	'sidebar-foreground': { source: 'base-content' },
+	'sidebar-primary': { source: 'primary' },
+	'sidebar-primary-foreground': { source: 'primary-content' },
+	'sidebar-accent': { source: 'base-300' },
+	'sidebar-accent-foreground': { source: 'base-content' },
+	'sidebar-ring': { source: 'primary' },
+	radius: { scalar: 'radius' }
+};
+
+// A mix row is a derivation over two sources. Values stay opaque: Tailwind's opacity modifiers
+// multiply alpha, so any alpha baked in here would be wrong at every use site.
+const MIX = {
+	'muted-foreground': ['base-content', 62, 'base-100'],
+	accent: ['base-200', 85, 'base-300'],
+	border: ['base-content', 10, 'base-100'],
+	input: ['base-content', 15, 'base-100'],
+	'sidebar-border': ['base-content', 10, 'base-100']
+};
+
+export const MIX_KEYS = Object.keys(MIX);
+
+// The colour source a mix row reads, so the plugin can emit exactly the bindings the map needs.
+export const mixSources = (key) => {
+	const row = MIX[key];
+	return row ? [row[0], row[2]] : [];
+};
+
+export const mixValue = (key, colorVar) => {
+	const row = MIX[key];
+	if (!row) throw new Error(`[daisyui-adapter] no mix row for ${key}`);
+	return `color-mix(in oklch, var(${colorVar(row[0])}) ${row[1]}%, var(${colorVar(row[2])}))`;
+};
+
+export const isSingle = (key) => key in SINGLE;
+export const isMix = (key) => key in MIX;
+
+// Every binding key the CLI writes into each block, in a stable order.
+export const BINDING_KEYS = [...Object.keys(SINGLE), ...MIX_KEYS];

package/dist/ramp.mjs

@@ -0,0 +1,188 @@
+// The chart ramp rule settled in ticket 12, in one place so the plugin and the writer cannot drift.
+//
+// One hue from the theme's `primary`, five lightness steps, chroma capped. Lightness is not shared
+// between schemes: the adapter solves one anchor for 3.2:1 against that scheme's own base-100 and
+// lays four more steps at a fixed offset. A shared band fails, because the light band puts chart-5
+// at 1.18:1 on daisyUI's dark page.
+//
+// Chroma is capped per step, not once for the ramp. sRGB cannot carry chroma 0.08 at every
+// lightness, so a single cap clips, and clipping moves the hue: on the daisyUI dark pair the top
+// step drifted 4.5 degrees. Fitting each step to the gamut keeps the hue constant and costs no
+// separation (worst adjacent dE 0.090 instead of 0.074).
+
+export const CAP = 0.08;
+export const STEP = 0.09;
+export const ANCHOR_RATIO = 3.2;
+export const STEPS = 5;
+export const MIN_ADJACENT_DELTA_E = 0.06;
+export const MIN_COMPLIANT_DELTA_E = 0.05;
+
+export const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+
+// Unclamped, so a caller can tell in-gamut from clipped.
+function rawLinear(L, C, h) {
+	const a = C * Math.cos((h * Math.PI) / 180);
+	const b = C * Math.sin((h * Math.PI) / 180);
+	const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+	const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+	const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+	return [
+		4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+		-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+		-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+	];
+}
+
+export const toLinear = (L, C, h) => rawLinear(L, C, h).map((v) => clamp(v, 0, 1));
+
+const inGamut = (L, C, h) => rawLinear(L, C, h).every((v) => v >= -0.0005 && v <= 1.0005);
+
+// The largest chroma sRGB can hold at this lightness and hue, to 4 decimal places.
+export function gamutChroma(L, h) {
+	let lo = 0;
+	let hi = 0.4;
+	for (let i = 0; i < 60; i++) {
+		const mid = (lo + hi) / 2;
+		if (inGamut(L, mid, h)) lo = mid;
+		else hi = mid;
+	}
+	return Math.floor(lo * 10000) / 10000;
+}
+
+export const luminance = (lin) => 0.2126 * lin[0] + 0.7152 * lin[1] + 0.0722 * lin[2];
+
+export const contrastLum = (a, b) => {
+	const [hi, lo] = [a, b].sort((x, y) => y - x);
+	return (hi + 0.05) / (lo + 0.05);
+};
+
+export const toOklab = (lin) => {
+	const [r, g, b] = lin;
+	const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+	const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+	const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+	return [
+		0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+		1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+		0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+	];
+};
+
+export const deltaE = (a, b) => {
+	const A = toOklab(a);
+	const B = toOklab(b);
+	return Math.hypot(A[0] - B[0], A[1] - B[1], A[2] - B[2]);
+};
+
+export const hueOf = (lin) => {
+	const [, a, b] = toOklab(lin);
+	return ((Math.atan2(b, a) * 180) / Math.PI + 360) % 360;
+};
+
+// The widest hue difference inside a set, measured the short way around the wheel.
+export function hueSpread(values) {
+	const hs = values.map(hueOf);
+	let worst = 0;
+	for (let i = 0; i < hs.length; i++) {
+		for (let j = i + 1; j < hs.length; j++) {
+			const d = Math.abs(hs[i] - hs[j]) % 360;
+			worst = Math.max(worst, Math.min(d, 360 - d));
+		}
+	}
+	return worst;
+}
+
+export function parseOklch(value) {
+	const match = /oklch\(\s*([\d.]+)(%)?\s+([\d.]+)\s+([\d.]+)/.exec(value ?? '');
+	if (!match) return null;
+	return { L: match[2] ? Number(match[1]) / 100 : Number(match[1]), C: Number(match[3]), h: Number(match[4]) };
+}
+
+// Reads one daisyUI theme block into its `--color-*` and radius keys.
+export function readThemeBlock(body) {
+	return Object.fromEntries(
+		[...body.matchAll(/(--[a-z0-9-]+)\s*:\s*([^;]+);/g)].map((m) => [m[1], m[2].trim()])
+	);
+}
+
+// Solves the five lightness values and the five chroma caps for one scheme.
+export function solveScheme(vars) {
+	const primary = parseOklch(vars['--color-primary']);
+	const surface = parseOklch(vars['--color-base-100']);
+	if (!primary || !surface) {
+		throw new Error('[chart-ramp] the theme needs a numeric --color-primary and --color-base-100');
+	}
+	const cappedBrand = Math.min(primary.C, CAP);
+	const surfaceLum = luminance(toLinear(surface.L, surface.C, surface.h));
+	const upward = 1.05 / (surfaceLum + 0.05) >= (surfaceLum + 0.05) / 0.05;
+	const direction = upward ? 1 : -1;
+
+	let lo = upward ? surface.L : 0;
+	let hi = upward ? 1 : surface.L;
+	let anchor = upward ? 0.97 : 0.03;
+	for (let i = 0; i < 90; i++) {
+		const mid = (lo + hi) / 2;
+		if (contrastLum(luminance(toLinear(mid, cappedBrand, primary.h)), surfaceLum) >= ANCHOR_RATIO) {
+			anchor = mid;
+			if (upward) hi = mid;
+			else lo = mid;
+		} else {
+			if (upward) lo = mid;
+			else hi = mid;
+		}
+	}
+
+	const lightness = [0, 1, 2, 3, 4].map((i) => anchor + direction * STEP * i);
+	const outside = lightness.filter((l) => l < 0.02 || l > 0.98);
+	if (outside.length > 0) {
+		throw new Error(
+			`[chart-ramp] base-100 at L ${surface.L.toFixed(3)} leaves no room for five steps ` +
+				`(${outside.length} of 5 outside L 0.02 to 0.98). A mid-tone surface cannot carry a one-hue ramp; ` +
+				`pick a base-100 closer to white or black, or supply chart values in the overrides file.`
+		);
+	}
+
+	const chroma = lightness.map((l) => Math.min(cappedBrand, gamutChroma(l, primary.h)));
+	const rgb = lightness.map((l, i) => toLinear(l, chroma[i], primary.h));
+	const contrast = rgb.map((c) => contrastLum(luminance(c), surfaceLum));
+	const adjacent = rgb.slice(1).map((c, i) => deltaE(c, rgb[i]));
+	const minAdjacent = Math.min(...adjacent);
+
+	if (minAdjacent < MIN_ADJACENT_DELTA_E) {
+		throw new Error(
+			`[chart-ramp] adjacent separation ${minAdjacent.toFixed(3)} is below ${MIN_ADJACENT_DELTA_E}`
+		);
+	}
+	if (contrast.some((c) => c < 3)) {
+		throw new Error(
+			`[chart-ramp] a step is below 3:1 against base-100: ${contrast.map((c) => c.toFixed(2)).join(', ')}`
+		);
+	}
+
+	const drift = hueSpread(rgb);
+	if (drift > 2) {
+		throw new Error(`[chart-ramp] the ramp drifts ${drift.toFixed(2)} degrees in hue, so it is not one hue`);
+	}
+
+	return {
+		anchor,
+		direction,
+		lightness,
+		chroma,
+		primary,
+		surface,
+		surfaceLum,
+		contrast,
+		adjacent,
+		minAdjacent,
+		hueSpread: drift
+	};
+}
+
+// The five token values. Hue and brand chroma stay live, so a later `primary` change flows through;
+// only the per-step chroma ceiling is baked, because sRGB needs a different ceiling per step.
+export function chartTokens(scheme) {
+	return scheme.lightness.map(
+		(l, i) => `oklch(from var(--daisy-color-primary) ${l.toFixed(4)} min(c, ${scheme.chroma[i]}) h)`
+	);
+}

package/package.json

@@ -1,6 +1,40 @@
-{
-  "name": "@kodaicoder/shadcn-svelte-daisyui-adapter",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+	"name": "@kodaicoder/shadcn-svelte-daisyui-adapter",
+	"version": "0.2.0",
+	"description": "Generate a shadcn-svelte token set from a daisyUI v5 theme, at build time, with no daisyUI runtime dependency.",
+	"license": "MIT",
+	"type": "module",
+	"bin": {
+		"daisyui-adapter": "cli/init.mjs"
+	},
+	"exports": {
+		".": {
+			"default": "./dist/index.mjs"
+		},
+		"./map": "./dist/map.mjs",
+		"./ramp": "./dist/ramp.mjs"
+	},
+	"files": [
+		"dist",
+		"cli",
+		"CHANGELOG.md"
+	],
+	"keywords": [
+		"daisyui",
+		"shadcn-svelte",
+		"sveltekit",
+		"tailwindcss",
+		"theme"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/kodaicoder/shadcn-svelte-daisyui-adapter.git",
+		"directory": "packages/daisyui-adapter"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}