@diskette/palette 0.22.1 → 0.23.0

package/dist/cli/cli.js

@@ -4,7 +4,8 @@ import { mkdirSync } from 'node:fs';
 import { relative, resolve } from 'node:path';
 import { accentColors, grayColors, } from "../types.js";
 import { getMatchingGrayColor } from "../utils.js";
-import { alphaColors, capitalize, getColorHex, writeAccentsFile, writeColorFiles, writeTailwindFile, } from "./utils.js";
+import { buildOutputFiles, confirmOverwrites, writeOutputFiles, } from "./output.js";
+import { alphaColors, capitalize, getColorHex } from "./utils.js";
 const accentOptions = {
     Accents: accentColors
         .filter((c) => c !== 'gray')
@@ -24,7 +25,7 @@ const grayOptions = grayColors.map((c) => {
     return { value: c, label: `${swatch}${capitalize(c)}` };
 });
 async function main() {
-    p.intro(`palette v0.22.1`);
+    p.intro(`palette v0.23.0`);
     const results = await p.group({
         colors: () => p.groupMultiselect({
             message: 'Select accent colors',
@@ -73,23 +74,25 @@ async function main() {
     const cwd = process.cwd();
     const outputPath = resolve(cwd, results.output);
     mkdirSync(outputPath, { recursive: true });
-    const s = p.spinner();
-    s.start('Generating CSS files...');
-    writeColorFiles(allColors, outputPath);
-    if (results.accents) {
-        writeAccentsFile(allColors, outputPath);
-    }
-    if (results.tailwind) {
-        writeTailwindFile(allColors, outputPath, results.accents);
-    }
+    // Build file list, confirm overwrites, and write
+    const allFiles = buildOutputFiles({
+        colors: allColors,
+        outputPath,
+        accents: results.accents,
+        tailwind: results.tailwind,
+    });
+    const filesToWrite = await confirmOverwrites(allFiles);
+    const s = p.spinner({ withGuide: false });
+    const writeResults = writeOutputFiles(filesToWrite);
     s.stop();
     const rel = relative(cwd, outputPath);
     const display = rel.startsWith('..') ? rel : `./${rel}`;
-    const extras = [
-        results.accents && 'accents.css',
-        results.tailwind && 'index.css',
-    ].filter(Boolean);
-    p.log.success(`Generated ${allColors.length} color${allColors.length > 1 ? 's' : ''}${extras.length ? ` + ${extras.join(', ')}` : ''}`);
+    const written = writeResults.filter((r) => r.status === 'written').length;
+    const skipped = allFiles.length - filesToWrite.length;
+    if (skipped > 0) {
+        p.log.warn(`Skipped ${skipped} existing file${skipped > 1 ? 's' : ''}`);
+    }
+    p.log.success(`Generated ${written} file${written !== 1 ? 's' : ''}`);
     p.outro(`Saved to ${display}`);
 }
 main();

package/dist/cli/output.d.ts

@@ -0,0 +1,19 @@
+export type OutputFile = {
+    path: string;
+    displayName: string;
+    content: () => string;
+    skipIfExists?: boolean;
+};
+export type WriteResult = {
+    path: string;
+    status: 'written' | 'skipped' | 'error';
+    error?: Error;
+};
+export declare function buildOutputFiles(config: {
+    colors: string[];
+    outputPath: string;
+    accents?: boolean;
+    tailwind?: boolean;
+}): OutputFile[];
+export declare function confirmOverwrites(files: OutputFile[]): Promise<OutputFile[]>;
+export declare function writeOutputFiles(files: OutputFile[]): WriteResult[];

package/dist/cli/output.js

@@ -0,0 +1,106 @@
+import * as p from '@clack/prompts';
+import { existsSync, writeFileSync } from 'node:fs';
+import { relative } from 'node:path';
+import * as palette from "../colors/index.js";
+import { css } from "../css.js";
+import {} from "../types.js";
+import { alphaColors, capitalize } from "./utils.js";
+function isAlphaColor(name) {
+    return alphaColors.includes(name);
+}
+function alphaColorFile(name, outputPath) {
+    const fileName = name === 'blackAlpha' ? 'black-alpha' : 'white-alpha';
+    return {
+        path: `${outputPath}/${fileName}.css`,
+        displayName: capitalize(fileName.replace('-', ' ')),
+        content: () => css.alpha(palette[name]),
+        skipIfExists: true,
+    };
+}
+function paletteColorFiles(name, outputPath) {
+    const color = palette[name];
+    return [
+        {
+            path: `${outputPath}/${name}.css`,
+            displayName: capitalize(name),
+            content: () => css.palette(color, { schemes: ['light'], alpha: true }),
+        },
+        {
+            path: `${outputPath}/${name}-dark.css`,
+            displayName: `${capitalize(name)} Dark`,
+            content: () => css.palette(color, { schemes: ['dark'], alpha: true }),
+        },
+    ];
+}
+function accentsFile(colorNames, outputPath) {
+    return {
+        path: `${outputPath}/accents.css`,
+        displayName: 'Accents',
+        content: () => css.accents(colorNames),
+    };
+}
+function tailwindFile(names, outputPath, accents) {
+    return {
+        path: `${outputPath}/index.css`,
+        displayName: 'Tailwind Config',
+        content: () => css.tailwind(names, { accents }),
+    };
+}
+export function buildOutputFiles(config) {
+    const { colors, outputPath, accents, tailwind } = config;
+    const files = [];
+    for (const name of colors) {
+        if (isAlphaColor(name)) {
+            files.push(alphaColorFile(name, outputPath));
+        }
+        else {
+            files.push(...paletteColorFiles(name, outputPath));
+        }
+    }
+    if (accents) {
+        const colorNames = colors.filter((c) => !isAlphaColor(c));
+        files.push(accentsFile(colorNames, outputPath));
+    }
+    if (tailwind) {
+        const tailwindNames = colors.map((c) => c === 'blackAlpha' ? 'black' : c === 'whiteAlpha' ? 'white' : c);
+        files.push(tailwindFile(tailwindNames, outputPath, accents ?? false));
+    }
+    return files;
+}
+export async function confirmOverwrites(files) {
+    const cwd = process.cwd();
+    const newFiles = files.filter((f) => !existsSync(f.path));
+    const existing = files.filter((f) => existsSync(f.path));
+    // Files that should prompt for overwrite confirmation
+    const promptable = existing.filter((f) => !f.skipIfExists);
+    if (promptable.length === 0) {
+        return newFiles;
+    }
+    const selected = await p.multiselect({
+        message: 'These files already exist. Select to overwrite:',
+        options: promptable.map((f) => ({
+            value: f.path,
+            label: f.displayName,
+            hint: relative(cwd, f.path),
+        })),
+        required: false,
+    });
+    if (p.isCancel(selected)) {
+        p.cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    const selectedSet = new Set(selected);
+    const toOverwrite = promptable.filter((f) => selectedSet.has(f.path));
+    return [...newFiles, ...toOverwrite];
+}
+export function writeOutputFiles(files) {
+    return files.map((file) => {
+        try {
+            writeFileSync(file.path, file.content());
+            return { path: file.path, status: 'written' };
+        }
+        catch (error) {
+            return { path: file.path, status: 'error', error: error };
+        }
+    });
+}

package/dist/cli/utils.d.ts

@@ -1,4 +1,3 @@
-import { type Color } from '../types.ts';
 export declare const alphaColors: readonly ["blackAlpha", "whiteAlpha"];
 export type AlphaColor = (typeof alphaColors)[number];
 /**
@@ -10,12 +9,6 @@ export declare const getPackageJson: (cwd: string) => {
     pkg: any;
     packageJsonPath: string;
 } | undefined;
-export declare function writeColorFiles(selected: string[], outputPath: string): void;
-export declare function writeAlphaColorFile(name: AlphaColor, outputPath: string): void;
-export declare function writePaletteColorFiles(name: Color, outputPath: string): void;
-export declare function writeAccentsFile(selected: string[], outputPath: string): void;
-export declare function writeTailwindFile(selected: string[], outputPath: string, includeAccents: boolean): void;
-export declare function writeIfNotExists(path: string, data: string | NodeJS.ArrayBufferView): boolean;
 export declare const capitalize: (s: string) => string;
 /** Get hex color (step 9) for a palette color */
 export declare const getColorHex: (name: string) => string | null;

package/dist/cli/utils.js

@@ -1,10 +1,8 @@
-import fs, { existsSync, writeFileSync } from 'node:fs';
+import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import * as url from 'node:url';
 import * as colors from "../colors/index.js";
-import * as palette from "../colors/index.js";
-import { css } from "../css.js";
 import {} from "../types.js";
 export const alphaColors = ['blackAlpha', 'whiteAlpha'];
 const require = createRequire(import.meta.url);
@@ -47,41 +45,6 @@ const findPackageJson = (startDir) => {
         currentDir = parentDir;
     }
 };
-export function writeColorFiles(selected, outputPath) {
-    for (const name of selected) {
-        if (alphaColors.includes(name)) {
-            writeAlphaColorFile(name, outputPath);
-        }
-        else {
-            writePaletteColorFiles(name, outputPath);
-        }
-    }
-}
-export function writeAlphaColorFile(name, outputPath) {
-    const config = palette[name];
-    const fileName = name === 'blackAlpha' ? 'black-alpha' : 'white-alpha';
-    writeIfNotExists(`${outputPath}/${fileName}.css`, css.alpha(config));
-}
-export function writePaletteColorFiles(name, outputPath) {
-    const color = palette[name];
-    writeIfNotExists(`${outputPath}/${name}.css`, css.palette(color, { schemes: ['light'], alpha: true }));
-    writeIfNotExists(`${outputPath}/${name}-dark.css`, css.palette(color, { schemes: ['dark'], alpha: true }));
-}
-export function writeAccentsFile(selected, outputPath) {
-    const accentColorNames = selected.filter((c) => !alphaColors.includes(c));
-    writeIfNotExists(`${outputPath}/accents.css`, css.accents(accentColorNames));
-}
-export function writeTailwindFile(selected, outputPath, includeAccents) {
-    const tailwindColorNames = selected.map((c) => c === 'blackAlpha' ? 'black' : c === 'whiteAlpha' ? 'white' : c);
-    writeIfNotExists(`${outputPath}/index.css`, css.tailwind(tailwindColorNames, { accents: includeAccents }));
-}
-export function writeIfNotExists(path, data) {
-    if (existsSync(path)) {
-        return false;
-    }
-    writeFileSync(path, data);
-    return true;
-}
 export const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
 /** Get hex color (step 9) for a palette color */
 export const getColorHex = (name) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diskette/palette",
   "type": "module",
-  "version": "0.22.1",
+  "version": "0.23.0",
   "bin": {
     "palette": "./dist/cli/cli.js"
   },