@vuetify/v0 0.1.6 → 0.1.7

package/dist/logger/index.d.mts

@@ -1,17 +1,6 @@
-import "../index-BFBN5Zl3.mjs";
-import "../adapter-CLs-OrSN.mjs";
-import { Cn as createLoggerPlugin, Sn as createLoggerContext, Tn as LogLevel, _n as LoggerContext, bn as LoggerPluginOptions, vn as LoggerContextOptions, wn as useLogger, xn as createLogger, yn as LoggerOptions } from "../index-De0SQt1w.mjs";
-import "../server-CGAeOGPC.mjs";
-import "../v0-CVr15VcY.mjs";
-import "../virtual-CVb9hRUU.mjs";
-import "../index-DIK84tM4.mjs";
-import "../adapter-DcwxFryd.mjs";
-import "../index-BuOz3Rgm.mjs";
-import "../v0-DHMoZ7dS.mjs";
-import { t as LoggerAdapter } from "../adapter-CJIj5ySf.mjs";
-import { t as ConsolaLoggerAdapter } from "../consola-DiUk9j3y.mjs";
-import { t as PinoLoggerAdapter } from "../pino-p-jDkNQd.mjs";
-import { t as Vuetify0LoggerAdapter } from "../v0-BOxb3nD1.mjs";
-import "../memory-DVjquu_v.mjs";
-import "../index-BDTbJClL.mjs";
+import { An as LoggerContextOptions, Fn as createLoggerPlugin, In as useLogger, Ln as LogLevel, Mn as LoggerPluginOptions, Nn as createLogger, Pn as createLoggerContext, jn as LoggerOptions, kn as LoggerContext } from "../index-BE848tZ2.mjs";
+import { t as LoggerAdapter } from "../adapter-JTFG3Jn8.mjs";
+import { t as ConsolaLoggerAdapter } from "../consola-BVzYzeLH.mjs";
+import { t as PinoLoggerAdapter } from "../pino-Bzighnkd.mjs";
+import { t as Vuetify0LoggerAdapter } from "../v0-1xxC39wf.mjs";
 export { ConsolaLoggerAdapter, LogLevel, LoggerAdapter, LoggerContext, LoggerContextOptions, LoggerOptions, LoggerPluginOptions, PinoLoggerAdapter, Vuetify0LoggerAdapter, createLogger, createLoggerContext, createLoggerPlugin, useLogger };

package/dist/logger/index.mjs

@@ -1,10 +1,8 @@
-import "../globals-D6FBsWDI.mjs";
-import "../utilities-CcJtp9Gx.mjs";
-import "../createTrinity-Cii8-B2r.mjs";
-import { i as useLogger, n as createLoggerContext, r as createLoggerPlugin, t as createLogger } from "../useLogger-C8G5jgNk.mjs";
-import { t as ConsolaLoggerAdapter } from "../consola-GBy8XRuL.mjs";
-import { t as PinoLoggerAdapter } from "../pino-BD5PCzAF.mjs";
-import { t as Vuetify0LoggerAdapter } from "../v0-lua6ffdk.mjs";
-import "../adapters-DEXpW9If.mjs";
-
-export { ConsolaLoggerAdapter, PinoLoggerAdapter, Vuetify0LoggerAdapter, createLogger, createLoggerContext, createLoggerPlugin, useLogger };
+import "../globals-BqRH_jdr.mjs";
+import "../createTrinity-C_c8eedz.mjs";
+import { i as useLogger, n as createLoggerContext, r as createLoggerPlugin, t as createLogger } from "../useLogger-B70T4SgK.mjs";
+import { t as ConsolaLoggerAdapter } from "../consola-Ceox8BWi.mjs";
+import { t as PinoLoggerAdapter } from "../pino-B7tJ3m18.mjs";
+import { t as Vuetify0LoggerAdapter } from "../v0-V-cQsuZD.mjs";
+import "../adapters-Bv5aRv3l.mjs";
+export { ConsolaLoggerAdapter, PinoLoggerAdapter, Vuetify0LoggerAdapter, createLogger, createLoggerContext, createLoggerPlugin, useLogger };

package/dist/{memory-BsZGbGnG.mjs → memory-XCMtkld1.mjs}

@@ -22,6 +22,5 @@ var MemoryAdapter = class {
 		return String(Array.from(this.store.keys())[index] ?? "");
 	}
 };
-
 //#endregion
-export { MemoryAdapter as t };
+export { MemoryAdapter as t };

package/dist/palettes/ant/generate/index.d.mts

@@ -0,0 +1,9 @@
+import { PaletteDefinition } from "../../index.mjs";
+
+//#region src/palettes/ant/generate/index.d.ts
+interface AntGenerateOptions {
+  background?: string;
+}
+declare function ant(seed: string, options?: AntGenerateOptions): PaletteDefinition;
+//#endregion
+export { AntGenerateOptions, ant };

package/dist/palettes/ant/generate/index.mjs

@@ -0,0 +1,98 @@
+import { generate } from "@ant-design/colors";
+//#region src/palettes/ant/generate/index.ts
+const HEX_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+function toRecord(colors) {
+	const record = {};
+	for (const [index, color] of colors.entries()) record[index + 1] = color;
+	return record;
+}
+function contrast(hex) {
+	const r = Number.parseInt(hex.slice(1, 3), 16);
+	const g = Number.parseInt(hex.slice(3, 5), 16);
+	const b = Number.parseInt(hex.slice(5, 7), 16);
+	return (.299 * r + .587 * g + .114 * b) / 255 > .5 ? "#000000" : "#ffffff";
+}
+function ant(seed, options = {}) {
+	if (!HEX_RE.test(seed)) throw new Error(`[@vuetify/v0] Invalid seed color: "${seed}". Expected a hex string (e.g., "#1677ff").`);
+	const { background = "#141414" } = options;
+	const light = generate(seed);
+	const dark = generate(seed, {
+		theme: "dark",
+		backgroundColor: background
+	});
+	const grey = generate("#8c8c8c");
+	const greyDark = generate("#8c8c8c", {
+		theme: "dark",
+		backgroundColor: background
+	});
+	return {
+		palette: {
+			primary: toRecord(light),
+			primaryDark: toRecord(dark),
+			neutral: toRecord(grey),
+			neutralDark: toRecord(greyDark)
+		},
+		themes: {
+			light: {
+				dark: false,
+				colors: {
+					"primary": light[5],
+					"on-primary": contrast(light[5]),
+					"primary-container": light[0],
+					"on-primary-container": light[4],
+					"secondary": light[6],
+					"on-secondary": contrast(light[6]),
+					"secondary-container": light[1],
+					"on-secondary-container": light[5],
+					"tertiary": light[7],
+					"on-tertiary": contrast(light[7]),
+					"tertiary-container": light[2],
+					"on-tertiary-container": light[6],
+					"error": "#ff4d4f",
+					"on-error": "#ffffff",
+					"error-container": "#fff2f0",
+					"on-error-container": "#a8071a",
+					"surface": grey[0],
+					"on-surface": grey[8],
+					"surface-variant": grey[1],
+					"on-surface-variant": grey[7],
+					"outline": grey[4],
+					"outline-variant": grey[3],
+					"background": "#ffffff",
+					"on-background": grey[9]
+				}
+			},
+			dark: {
+				dark: true,
+				colors: {
+					"primary": dark[5],
+					"on-primary": contrast(dark[5]),
+					"primary-container": dark[8],
+					"on-primary-container": dark[4],
+					"secondary": dark[6],
+					"on-secondary": contrast(dark[6]),
+					"secondary-container": dark[7],
+					"on-secondary-container": dark[3],
+					"tertiary": dark[7],
+					"on-tertiary": contrast(dark[7]),
+					"tertiary-container": dark[8],
+					"on-tertiary-container": dark[4],
+					"error": "#ff7875",
+					"on-error": "#000000",
+					"error-container": "#5c0011",
+					"on-error-container": "#ffccc7",
+					"surface": greyDark[1],
+					"on-surface": greyDark[7],
+					"surface-variant": greyDark[2],
+					"on-surface-variant": greyDark[6],
+					"outline": greyDark[4],
+					"outline-variant": greyDark[3],
+					background,
+					"on-background": greyDark[8]
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { ant };

package/dist/palettes/ant/index.d.mts

@@ -0,0 +1,6 @@
+import { r as TokenCollection } from "../../index-8sflFIN8.mjs";
+
+//#region src/palettes/ant/index.d.ts
+declare const ant: TokenCollection;
+//#endregion
+export { ant };

package/dist/palettes/ant/index.mjs

@@ -0,0 +1,149 @@
+//#region src/palettes/ant/index.ts
+const ant = {
+	red: {
+		1: "#fff1f0",
+		2: "#ffccc7",
+		3: "#ffa39e",
+		4: "#ff7875",
+		5: "#ff4d4f",
+		6: "#f5222d",
+		7: "#cf1322",
+		8: "#a8071a",
+		9: "#820014",
+		10: "#5c0011"
+	},
+	volcano: {
+		1: "#fff2e8",
+		2: "#ffd8bf",
+		3: "#ffbb96",
+		4: "#ff9c6e",
+		5: "#ff7a45",
+		6: "#fa541c",
+		7: "#d4380d",
+		8: "#ad2102",
+		9: "#871400",
+		10: "#610b00"
+	},
+	orange: {
+		1: "#fff7e6",
+		2: "#ffe7ba",
+		3: "#ffd591",
+		4: "#ffc069",
+		5: "#ffa940",
+		6: "#fa8c16",
+		7: "#d46b08",
+		8: "#ad4e00",
+		9: "#873800",
+		10: "#612500"
+	},
+	gold: {
+		1: "#fffbe6",
+		2: "#fff1b8",
+		3: "#ffe58f",
+		4: "#ffd666",
+		5: "#ffc53d",
+		6: "#faad14",
+		7: "#d48806",
+		8: "#ad6800",
+		9: "#874d00",
+		10: "#613400"
+	},
+	yellow: {
+		1: "#feffe6",
+		2: "#ffffb8",
+		3: "#fffb8f",
+		4: "#fff566",
+		5: "#ffec3d",
+		6: "#fadb14",
+		7: "#d4b106",
+		8: "#ad8b00",
+		9: "#876800",
+		10: "#614700"
+	},
+	lime: {
+		1: "#fcffe6",
+		2: "#f4ffb8",
+		3: "#eaff8f",
+		4: "#d3f261",
+		5: "#bae637",
+		6: "#a0d911",
+		7: "#7cb305",
+		8: "#5b8c00",
+		9: "#3f6600",
+		10: "#254000"
+	},
+	green: {
+		1: "#f6ffed",
+		2: "#d9f7be",
+		3: "#b7eb8f",
+		4: "#95de64",
+		5: "#73d13d",
+		6: "#52c41a",
+		7: "#389e0d",
+		8: "#237804",
+		9: "#135200",
+		10: "#092b00"
+	},
+	cyan: {
+		1: "#e6fffb",
+		2: "#b5f5ec",
+		3: "#87e8de",
+		4: "#5cdbd3",
+		5: "#36cfc9",
+		6: "#13c2c2",
+		7: "#08979c",
+		8: "#006d75",
+		9: "#00474f",
+		10: "#002329"
+	},
+	blue: {
+		1: "#e6f4ff",
+		2: "#bae0ff",
+		3: "#91caff",
+		4: "#69b1ff",
+		5: "#4096ff",
+		6: "#1677ff",
+		7: "#0958d9",
+		8: "#003eb3",
+		9: "#002c8c",
+		10: "#001d66"
+	},
+	geekblue: {
+		1: "#f0f5ff",
+		2: "#d6e4ff",
+		3: "#adc6ff",
+		4: "#85a5ff",
+		5: "#597ef7",
+		6: "#2f54eb",
+		7: "#1d39c4",
+		8: "#10239e",
+		9: "#061178",
+		10: "#030852"
+	},
+	purple: {
+		1: "#f9f0ff",
+		2: "#efdbff",
+		3: "#d3adf7",
+		4: "#b37feb",
+		5: "#9254de",
+		6: "#722ed1",
+		7: "#531dab",
+		8: "#391085",
+		9: "#22075e",
+		10: "#120338"
+	},
+	magenta: {
+		1: "#fff0f6",
+		2: "#ffd6e7",
+		3: "#ffadd2",
+		4: "#ff85c0",
+		5: "#f759ab",
+		6: "#eb2f96",
+		7: "#c41d7f",
+		8: "#9e1068",
+		9: "#780650",
+		10: "#520339"
+	}
+};
+//#endregion
+export { ant };

package/dist/palettes/index.d.mts

@@ -0,0 +1,12 @@
+import { o as ID } from "../index-Dor6eAEc.mjs";
+import { r as TokenCollection } from "../index-8sflFIN8.mjs";
+import { D as ThemeRecord } from "../index-BE848tZ2.mjs";
+
+//#region src/palettes/index.d.ts
+interface PaletteDefinition {
+  palette: TokenCollection;
+  themes: Record<ID, ThemeRecord>;
+}
+type PaletteGenerator<O = {}> = (seed: string, options?: O) => PaletteDefinition;
+//#endregion
+export { PaletteDefinition, PaletteGenerator };

package/dist/palettes/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/palettes/leonardo/generate/index.d.mts

@@ -0,0 +1,10 @@
+import { PaletteDefinition } from "../../index.mjs";
+
+//#region src/palettes/leonardo/generate/index.d.ts
+interface LeonardoGenerateOptions {
+  ratios?: number[];
+  colorSpace?: 'CAM02' | 'CAM02p' | 'HSL' | 'HSLuv' | 'HSV' | 'LAB' | 'LCH' | 'OKLAB' | 'OKLCH' | 'RGB';
+}
+declare function leonardo(seed: string, options?: LeonardoGenerateOptions): PaletteDefinition;
+//#endregion
+export { LeonardoGenerateOptions, leonardo };

package/dist/palettes/leonardo/generate/index.mjs

@@ -0,0 +1,120 @@
+import { Color, Theme } from "@adobe/leonardo-contrast-colors";
+//#region src/palettes/leonardo/generate/index.ts
+const DEFAULT_RATIOS = [
+	1.25,
+	1.5,
+	2,
+	3,
+	4.5,
+	7,
+	11
+];
+const HEX_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+function extractColors(entries) {
+	const colors = {};
+	for (const entry of entries) if (entry && typeof entry === "object" && "values" in entry) {
+		const e = entry;
+		for (const v of e.values) colors[v.contrast] = v.value;
+	}
+	return colors;
+}
+function mapSemanticColors(colors, ratios) {
+	function at(ratio) {
+		if (colors[ratio]) return colors[ratio];
+		let closest = ratios[0];
+		let delta = Math.abs(ratio - closest);
+		for (const r of ratios) {
+			const d = Math.abs(ratio - r);
+			if (d < delta) {
+				closest = r;
+				delta = d;
+			}
+		}
+		return colors[closest] ?? Object.values(colors)[0] ?? "#000000";
+	}
+	const low1 = at(1.25);
+	const low2 = at(1.5);
+	const low3 = at(2);
+	const mid1 = at(3);
+	const mid2 = at(4.5);
+	const high1 = at(7);
+	const high2 = at(11);
+	return {
+		"primary": mid2,
+		"on-primary": high2,
+		"primary-container": low1,
+		"on-primary-container": high1,
+		"secondary": mid2,
+		"on-secondary": high2,
+		"secondary-container": low2,
+		"on-secondary-container": high1,
+		"tertiary": mid2,
+		"on-tertiary": high2,
+		"tertiary-container": low3,
+		"on-tertiary-container": high1,
+		"surface": low1,
+		"on-surface": high1,
+		"surface-variant": low1,
+		"on-surface-variant": high1,
+		"outline": mid1,
+		"outline-variant": low2
+	};
+}
+function leonardo(seed, options = {}) {
+	if (!HEX_RE.test(seed)) throw new Error(`[@vuetify/v0] Invalid seed color: "${seed}". Expected a hex string (e.g., "#0ea5e9").`);
+	const { ratios = DEFAULT_RATIOS, colorSpace = "OKLCH" } = options;
+	const color = new Color({
+		name: "primary",
+		colorKeys: [seed],
+		ratios,
+		colorSpace
+	});
+	const light = new Theme({
+		colors: [color],
+		backgroundColor: "#ffffff",
+		lightness: 100
+	});
+	const dark = new Theme({
+		colors: [color],
+		backgroundColor: "#121212",
+		lightness: 8
+	});
+	const lightColors = extractColors(light.contrastColors);
+	const darkColors = extractColors(dark.contrastColors);
+	const lightSemantic = mapSemanticColors(lightColors, ratios);
+	const darkSemantic = mapSemanticColors(darkColors, ratios);
+	return {
+		palette: {
+			primary: lightColors,
+			primaryDark: darkColors
+		},
+		themes: {
+			light: {
+				dark: false,
+				colors: {
+					...lightSemantic,
+					"error": "#ba1a1a",
+					"on-error": "#ffffff",
+					"error-container": "#ffdad6",
+					"on-error-container": "#410002",
+					"background": "#ffffff",
+					"on-background": lightSemantic["on-surface"] ?? "#000000"
+				}
+			},
+			dark: {
+				dark: true,
+				colors: {
+					...darkSemantic,
+					"error": "#ffb4ab",
+					"on-error": "#690005",
+					"error-container": "#93000a",
+					"on-error-container": "#ffdad6",
+					"background": "#121212",
+					"on-background": darkSemantic["on-surface"] ?? "#ffffff"
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { leonardo };

package/dist/palettes/material/generate/index.d.mts

@@ -0,0 +1,10 @@
+import { PaletteDefinition } from "../../index.mjs";
+
+//#region src/palettes/material/generate/index.d.ts
+interface MaterialGenerateOptions {
+  variant?: 'tonalSpot' | 'vibrant' | 'expressive' | 'fidelity' | 'monochrome' | 'neutral';
+  contrast?: number;
+}
+declare function material(seed: string, options?: MaterialGenerateOptions): PaletteDefinition;
+//#endregion
+export { MaterialGenerateOptions, material };

package/dist/palettes/material/generate/index.mjs

@@ -0,0 +1,103 @@
+import { Hct, SchemeExpressive, SchemeFidelity, SchemeMonochrome, SchemeNeutral, SchemeTonalSpot, SchemeVibrant, argbFromHex, hexFromArgb } from "@material/material-color-utilities";
+//#region src/palettes/material/generate/index.ts
+const VARIANTS = {
+	tonalSpot: SchemeTonalSpot,
+	vibrant: SchemeVibrant,
+	expressive: SchemeExpressive,
+	fidelity: SchemeFidelity,
+	monochrome: SchemeMonochrome,
+	neutral: SchemeNeutral
+};
+const TONES = [
+	0,
+	4,
+	6,
+	10,
+	12,
+	17,
+	20,
+	22,
+	24,
+	25,
+	30,
+	35,
+	40,
+	50,
+	60,
+	70,
+	80,
+	87,
+	90,
+	92,
+	94,
+	95,
+	96,
+	98,
+	99,
+	100
+];
+const HEX_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+function extractTones(palette) {
+	const tones = {};
+	for (const tone of TONES) tones[tone] = hexFromArgb(palette.tone(tone));
+	return tones;
+}
+function extractSchemeColors(scheme) {
+	return {
+		"primary": hexFromArgb(scheme.primary),
+		"on-primary": hexFromArgb(scheme.onPrimary),
+		"primary-container": hexFromArgb(scheme.primaryContainer),
+		"on-primary-container": hexFromArgb(scheme.onPrimaryContainer),
+		"secondary": hexFromArgb(scheme.secondary),
+		"on-secondary": hexFromArgb(scheme.onSecondary),
+		"secondary-container": hexFromArgb(scheme.secondaryContainer),
+		"on-secondary-container": hexFromArgb(scheme.onSecondaryContainer),
+		"tertiary": hexFromArgb(scheme.tertiary),
+		"on-tertiary": hexFromArgb(scheme.onTertiary),
+		"tertiary-container": hexFromArgb(scheme.tertiaryContainer),
+		"on-tertiary-container": hexFromArgb(scheme.onTertiaryContainer),
+		"error": hexFromArgb(scheme.error),
+		"on-error": hexFromArgb(scheme.onError),
+		"error-container": hexFromArgb(scheme.errorContainer),
+		"on-error-container": hexFromArgb(scheme.onErrorContainer),
+		"surface": hexFromArgb(scheme.surface),
+		"on-surface": hexFromArgb(scheme.onSurface),
+		"surface-variant": hexFromArgb(scheme.surfaceVariant),
+		"on-surface-variant": hexFromArgb(scheme.onSurfaceVariant),
+		"outline": hexFromArgb(scheme.outline),
+		"outline-variant": hexFromArgb(scheme.outlineVariant),
+		"background": hexFromArgb(scheme.background),
+		"on-background": hexFromArgb(scheme.onBackground)
+	};
+}
+function material(seed, options = {}) {
+	if (!HEX_RE.test(seed)) throw new Error(`[@vuetify/v0] Invalid seed color: "${seed}". Expected a hex string (e.g., "#6750A4").`);
+	const { variant = "tonalSpot", contrast = 0 } = options;
+	const hct = Hct.fromInt(argbFromHex(seed));
+	const SchemeClass = VARIANTS[variant];
+	if (!SchemeClass) throw new Error(`[@vuetify/v0] Unknown material variant: "${variant}"`);
+	const light = new SchemeClass(hct, false, contrast);
+	const dark = new SchemeClass(hct, true, contrast);
+	return {
+		palette: {
+			primary: extractTones(light.primaryPalette),
+			secondary: extractTones(light.secondaryPalette),
+			tertiary: extractTones(light.tertiaryPalette),
+			neutral: extractTones(light.neutralPalette),
+			neutralVariant: extractTones(light.neutralVariantPalette),
+			error: extractTones(light.errorPalette)
+		},
+		themes: {
+			light: {
+				dark: false,
+				colors: extractSchemeColors(light)
+			},
+			dark: {
+				dark: true,
+				colors: extractSchemeColors(dark)
+			}
+		}
+	};
+}
+//#endregion
+export { material };

package/dist/palettes/material/index.d.mts

@@ -0,0 +1,6 @@
+import { r as TokenCollection } from "../../index-8sflFIN8.mjs";
+
+//#region src/palettes/material/index.d.ts
+declare const material: TokenCollection;
+//#endregion
+export { material };