@diskette/palette 0.18.0 → 0.20.0

package/dist/index.js

@@ -62,8 +62,7 @@ export const colors = {
     violet,
     yellow,
 };
-colors['amber'];
 export default colors;
 export { accentColors, grayColors } from "./types.js";
-export { css } from "./css.js";
-export { getMatchingGrayColor } from "./utils.js";
+export { applyColorVars, css } from "./css.js";
+export { getMatchingGrayColor, toVarName } from "./utils.js";

package/dist/types.d.ts

@@ -3,37 +3,38 @@ export type GrayColor = (typeof grayColors)[number];
 export declare const accentColors: readonly ["gray", "gold", "bronze", "brown", "yellow", "amber", "orange", "tomato", "red", "ruby", "crimson", "pink", "plum", "purple", "violet", "iris", "indigo", "blue", "cyan", "teal", "jade", "green", "grass", "lime", "mint", "sky"];
 export type AccentColor = (typeof accentColors)[number];
 export type Color = AccentColor | GrayColor;
-type ScaleStep = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
-export type ScaleSteps<C extends Color> = {
-    [K in `${C}${ScaleStep}` | `${C}A${ScaleStep}`]: string;
-};
-export type ColorScale<C extends Color> = {
+type Tuple<T, N extends number, R extends T[] = []> = R['length'] extends N ? R : Tuple<T, N, [...R, T]>;
+export type ScaleSteps = Tuple<string, 12>;
+export interface ColorScale {
+    solid: ScaleSteps;
+    alpha: ScaleSteps;
+}
+export interface PaletteColor<C extends Color> {
     name: C;
-    srgb: {
-        light: ScaleSteps<C>;
-        dark: ScaleSteps<C>;
+    contrast: string;
+    indicator: number;
+    track: number;
+    light: {
+        srgb: ColorScale;
+        p3: ColorScale;
     };
-    p3: {
-        light: ScaleSteps<C>;
-        dark: ScaleSteps<C>;
+    dark: {
+        srgb: ColorScale;
+        p3: ColorScale;
     };
-    contrast: string;
-    indicator: string;
-    track: string;
     surface: {
-        srgb: {
-            light: string;
-            dark: string;
+        light: {
+            srgb: string;
+            p3: string;
         };
-        p3: {
-            light: string;
-            dark: string;
+        dark: {
+            srgb: string;
+            p3: string;
         };
     };
-};
-export type AnyColorScale = ColorScale<any>;
+}
 export type AlphaScale<C extends 'white' | 'back'> = {
-    [K in `${C}A${ScaleStep}`]: string;
+    [K in `${C}A${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12}`]: string;
 };
 export type AlphaConfig<C extends 'white' | 'back'> = {
     name: C;

package/dist/utils.d.ts

@@ -8,3 +8,12 @@ export declare const toVarName: (key: string) => string;
 export declare const formatRule: (selector: string, vars: string[]) => string;
 export declare const formatP3: (selector: string, vars: string[]) => string;
 export declare const formatNestedBlock: (selector: string, vars: string[]) => string;
+/**
+ * get package.json content from startDir
+ * @param cwd
+ * @returns package.json content
+ */
+export declare const getPackageJson: (cwd: string) => {
+    pkg: any;
+    packageJsonPath: string;
+} | undefined;

package/dist/utils.js

@@ -1,3 +1,7 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import * as url from 'node:url';
 export function getMatchingGrayColor(accentColor) {
     switch (accentColor) {
         case 'tomato':
@@ -43,3 +47,43 @@ export const toVarName = (key) => `--${key.replace(/A?(\d+)/, (m, n) => (m.start
 export const formatRule = (selector, vars) => `${selector} {\n  ${vars.join(';\n  ')};\n}`;
 export const formatP3 = (selector, vars) => `@supports (color: color(display-p3 1 1 1)) {\n  @media (color-gamut: p3) {\n    ${selector} {\n      ${vars.join(';\n      ')};\n    }\n  }\n}`;
 export const formatNestedBlock = (selector, vars) => `&:where(${selector}) {\n    ${vars.join(';\n    ')};\n  }`;
+const require = createRequire(import.meta.url);
+/**
+ * get package.json content from startDir
+ * @param cwd
+ * @returns package.json content
+ */
+export const getPackageJson = (cwd) => {
+    try {
+        const startDir = path.dirname(url.fileURLToPath(cwd));
+        const packageJsonPath = findPackageJson(startDir);
+        if (packageJsonPath) {
+            const pkg = require(packageJsonPath);
+            return { pkg, packageJsonPath };
+        }
+        return undefined;
+    }
+    catch (error) {
+        // ignore error
+        return undefined;
+    }
+};
+/**
+ * search package.json from startDir
+ * @param startDir
+ * @returns
+ */
+const findPackageJson = (startDir) => {
+    let currentDir = startDir;
+    while (true) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        const parentDir = path.resolve(currentDir, '..');
+        if (parentDir === currentDir) {
+            return '';
+        }
+        currentDir = parentDir;
+    }
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diskette/palette",
   "type": "module",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "bin": {
     "palette": "./dist/cli/cli.js"
   },
@@ -23,12 +23,13 @@
     "dist"
   ],
   "dependencies": {
-    "cleye": "^2.0.1",
-    "type-flag": "^4.0.2"
+    "citty": "^0.1.6"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.7",
+    "@diskette/fs": "^0.17.0",
     "@types/node": "^24.3.0",
+    "magicast": "^0.5.1",
     "oxlint": "^1.16.0",
     "oxlint-tsgolint": "^0.2.0",
     "prettier": "^3.6.2",

package/dist/cli/commands/generate.d.ts

@@ -1,64 +0,0 @@
-export declare const generate: import("cleye").Command<{
-    name: "generate";
-    alias: "gen";
-    parameters: "[colors]"[];
-    flags: {
-        grays: {
-            type: StringConstructor;
-            alias: string;
-            description: string;
-        };
-        accents: {
-            type: BooleanConstructor;
-            alias: string;
-            description: string;
-            default: boolean;
-        };
-        output: {
-            type: StringConstructor;
-            alias: string;
-            description: string;
-        };
-    };
-    help: {
-        description: string;
-        examples: string[];
-    };
-}, {
-    command: "generate";
-} & import("type-flag").TypeFlag<{
-    grays: {
-        type: StringConstructor;
-        alias: string;
-        description: string;
-    };
-    accents: {
-        type: BooleanConstructor;
-        alias: string;
-        description: string;
-        default: boolean;
-    };
-    output: {
-        type: StringConstructor;
-        alias: string;
-        description: string;
-    };
-} & {
-    help: BooleanConstructor;
-}> & {
-    _: {
-        colors: string | undefined;
-    };
-    showHelp: (options?: {
-        version?: string;
-        description?: string;
-        usage?: false | string | string[];
-        examples?: string | string[];
-        render?: (nodes: {
-            id?: string;
-            type: keyof import("cleye").Renderers;
-            data: any;
-        }[], renderers: import("cleye").Renderers) => string;
-    }) => void;
-    showVersion: () => void;
-}>;

package/dist/cli/commands/generate.js

@@ -1,87 +0,0 @@
-import { command } from 'cleye';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { blackAlpha, whiteAlpha } from "../../colors/index.js";
-import { css } from "../../css.js";
-import { accentColors, colors, grayColors } from "../../index.js";
-function parseColors(input, available) {
-    if (!input)
-        return [];
-    if (input === 'all')
-        return [...available];
-    return input.split(',').filter((c) => available.includes(c));
-}
-export const generate = command({
-    name: 'generate',
-    alias: 'gen',
-    parameters: ['[colors]'],
-    flags: {
-        grays: {
-            type: String,
-            alias: 'g',
-            description: 'Gray colors to generate (comma-separated or "all")',
-        },
-        accents: {
-            type: Boolean,
-            alias: 'a',
-            description: 'Generate accents.css with semantic accent tokens',
-            default: false,
-        },
-        output: {
-            type: String,
-            alias: 'o',
-            description: 'Output directory',
-        },
-    },
-    help: {
-        description: 'Generate CSS files for color palettes',
-        examples: [
-            'palette generate blue,red -g slate -a -o ./styles',
-            'palette gen all -g all -a -o ./styles',
-        ],
-    },
-}, (argv) => {
-    if (!argv.flags.output) {
-        console.error('Error: --output (-o) is required');
-        process.exit(1);
-    }
-    const selectedAccentColors = parseColors(argv._.colors, accentColors);
-    const selectedGrayColors = parseColors(argv.flags.grays, grayColors.filter((g) => g !== 'gray'));
-    const selectedColors = [...selectedAccentColors, ...selectedGrayColors];
-    if (selectedColors.length === 0) {
-        console.error('No colors selected. Use positional args or --grays flag.');
-        console.error('Run "palette list" to see available colors.');
-        process.exit(1);
-    }
-    const outputPath = resolve(process.cwd(), argv.flags.output);
-    mkdirSync(outputPath, { recursive: true });
-    for (const name of selectedColors) {
-        const palette = colors[name];
-        writeFileSync(`${outputPath}/${name}.css`, css.palette(name, palette, { schemes: ['light'], alpha: true }));
-        writeFileSync(`${outputPath}/${name}-dark.css`, css.palette(name, palette, { schemes: ['dark'], alpha: true }));
-        console.log(`  ${name}.css, ${name}-dark.css`);
-    }
-    writeFileSync(`${outputPath}/black-alpha.css`, css.alpha(blackAlpha));
-    writeFileSync(`${outputPath}/white-alpha.css`, css.alpha(whiteAlpha));
-    console.log('  black-alpha.css, white-alpha.css');
-    if (argv.flags.accents) {
-        const accents = css.accents([...selectedAccentColors]);
-        const grays = css.grays(selectedGrayColors, 'diskette-palette');
-        writeFileSync(`${outputPath}/accents.css`, `${accents}\n${grays}`);
-        console.log('  accents.css');
-    }
-    const imports = [
-        ...(argv.flags.accents ? ['./accents.css'] : []),
-        ...selectedColors.flatMap((name) => [
-            `./${name}.css`,
-            `./${name}-dark.css`,
-        ]),
-        './black-alpha.css',
-        './white-alpha.css',
-    ]
-        .map((path) => `@import '${path}';`)
-        .join('\n');
-    writeFileSync(`${outputPath}/index.css`, `${imports}\n\n${css.tailwind(['white', 'black', 'accent', ...selectedColors])}`);
-    console.log('  index.css');
-    console.log(`\nCSS saved to ${outputPath}`);
-});

package/dist/cli/commands/list.d.ts

@@ -1,48 +0,0 @@
-export declare const list: import("cleye").Command<{
-    name: "list";
-    alias: "ls";
-    flags: {
-        accent: {
-            type: BooleanConstructor;
-            description: string;
-            default: boolean;
-        };
-        gray: {
-            type: BooleanConstructor;
-            description: string;
-            default: boolean;
-        };
-    };
-    help: {
-        description: string;
-    };
-}, {
-    command: "list";
-} & import("type-flag").TypeFlag<{
-    accent: {
-        type: BooleanConstructor;
-        description: string;
-        default: boolean;
-    };
-    gray: {
-        type: BooleanConstructor;
-        description: string;
-        default: boolean;
-    };
-} & {
-    help: BooleanConstructor;
-}> & {
-    _: {};
-    showHelp: (options?: {
-        version?: string;
-        description?: string;
-        usage?: false | string | string[];
-        examples?: string | string[];
-        render?: (nodes: {
-            id?: string;
-            type: keyof import("cleye").Renderers;
-            data: any;
-        }[], renderers: import("cleye").Renderers) => string;
-    }) => void;
-    showVersion: () => void;
-}>;

package/dist/cli/commands/list.js

@@ -1,33 +0,0 @@
-import { command } from 'cleye';
-import { accentColors, grayColors } from "../../index.js";
-export const list = command({
-    name: 'list',
-    alias: 'ls',
-    flags: {
-        accent: {
-            type: Boolean,
-            description: 'List only accent colors',
-            default: false,
-        },
-        gray: {
-            type: Boolean,
-            description: 'List only gray colors',
-            default: false,
-        },
-    },
-    help: {
-        description: 'List available colors',
-    },
-}, (argv) => {
-    const showAll = !argv.flags.accent && !argv.flags.gray;
-    if (showAll || argv.flags.accent) {
-        console.log('Accent colors:');
-        console.log(`  ${accentColors.join(', ')}`);
-    }
-    if (showAll)
-        console.log();
-    if (showAll || argv.flags.gray) {
-        console.log('Gray colors:');
-        console.log(`  ${grayColors.filter((g) => g !== 'gray').join(', ')}`);
-    }
-});