@diskette/palette 0.23.1 → 0.24.0

package/dist/cli/cli.js

@@ -2,47 +2,50 @@ import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { mkdirSync } from 'node:fs';
 import { relative, resolve } from 'node:path';
-import { accentColors, grayColors, } from "../types.js";
+import { accentColors, grayColors } from "../types.js";
 import { getMatchingGrayColor } from "../utils.js";
 import { buildOutputFiles, confirmOverwrites, writeOutputFiles, } from "./output.js";
-import { alphaColors, capitalize, getColorHex } from "./utils.js";
+import { alphaColors, capitalize, getColorHex, invariant } from "./utils.js";
+const accentOptionsList = [...accentColors];
+const alphaOptionsList = [...alphaColors];
 const accentOptions = {
-    Accents: accentColors
-        .filter((c) => c !== 'gray')
-        .map((c) => {
+    Accents: accentOptionsList.map((c) => {
         const hex = getColorHex(c);
         const swatch = hex ? chalk.bgHex(hex)('  ') + ' ' : '';
         return { value: c, label: `${swatch}${capitalize(c)}` };
     }),
-    Alpha: alphaColors.map((c) => {
+    Alpha: alphaOptionsList.map((c) => {
         const [label] = c.split('Alpha');
         return { value: c, label: capitalize(label) };
     }),
 };
-const grayOptions = grayColors.map((c) => {
+const grayOptionsList = [...grayColors];
+const grayOptions = grayOptionsList.map((c) => {
     const hex = getColorHex(c);
     const swatch = hex ? chalk.bgHex(hex)('  ') + ' ' : '';
     return { value: c, label: `${swatch}${capitalize(c)}` };
 });
 async function main() {
-    p.intro(`palette v0.23.1`);
+    p.intro(`palette v0.24.0`);
     const results = await p.group({
         colors: () => p.groupMultiselect({
             message: 'Select accent colors',
             options: accentOptions,
             required: true,
-            initialValues: [...alphaColors],
+            initialValues: alphaOptionsList,
         }),
         grays: ({ results }) => {
-            // Get matching grays for selected accent colors
-            const selectedAccents = (results.colors ?? []).filter((c) => accentColors.includes(c));
-            const matchingGrays = [
-                ...new Set(selectedAccents.map(getMatchingGrayColor)),
-            ];
+            const colors = results.colors ?? [];
+            const grays = [];
+            for (const color of colors) {
+                if (accentOptionsList.includes(color)) {
+                    grays.push(getMatchingGrayColor(color));
+                }
+            }
             return p.multiselect({
                 message: 'Select gray colors (natural pairings pre-selected)',
                 options: grayOptions,
-                initialValues: matchingGrays,
+                initialValues: grays,
                 required: false,
             });
         },
@@ -65,22 +68,15 @@ async function main() {
             process.exit(0);
         },
     });
-    const selectedGrays = (results.grays ?? []);
-    const allColors = [...results.colors, ...selectedGrays];
-    if (allColors.length === 0) {
-        p.cancel('No colors selected.');
-        process.exit(0);
-    }
+    // TODO: figure out why results.grays is typed as unknown
+    invariant(Array.isArray(results.grays) &&
+        results.grays.every((g) => typeof g === 'string'));
+    const grays = results.grays;
     const cwd = process.cwd();
     const outputPath = resolve(cwd, results.output);
     mkdirSync(outputPath, { recursive: true });
     // Build file list, confirm overwrites, and write
-    const allFiles = buildOutputFiles({
-        colors: allColors,
-        outputPath,
-        accents: results.accents,
-        tailwind: results.tailwind,
-    });
+    const allFiles = buildOutputFiles(outputPath, { ...results, grays });
     const filesToWrite = await confirmOverwrites(allFiles);
     const s = p.spinner({ withGuide: false });
     const writeResults = writeOutputFiles(filesToWrite);

package/dist/cli/output.d.ts

@@ -8,11 +8,11 @@ export type WriteResult = {
     status: 'written' | 'skipped' | 'error';
     error?: Error;
 };
-export declare function buildOutputFiles(config: {
+export declare function buildOutputFiles(outputPath: string, results: {
     colors: string[];
-    outputPath: string;
-    accents?: boolean;
-    tailwind?: boolean;
+    grays: 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

@@ -36,11 +36,17 @@ function paletteColorFiles(name, outputPath) {
         },
     ];
 }
-function accentsFile(colorNames, outputPath) {
+function accentsFile(colorNames, grayNames, outputPath) {
     return {
         path: `${outputPath}/accents.css`,
         displayName: 'Accents',
-        content: () => css.accents(colorNames),
+        content: () => {
+            const parts = [css.accents(colorNames)];
+            if (grayNames.length > 0) {
+                parts.push(css.grays(grayNames));
+            }
+            return parts.join('\n');
+        },
     };
 }
 function tailwindFile(names, outputPath, accents) {
@@ -50,8 +56,9 @@ function tailwindFile(names, outputPath, accents) {
         content: () => css.tailwind(names, { accents }),
     };
 }
-export function buildOutputFiles(config) {
-    const { colors, outputPath, accents, tailwind } = config;
+export function buildOutputFiles(outputPath, results) {
+    const { grays, accents, tailwind } = results;
+    const colors = [...results.colors, ...results.grays];
     const files = [];
     for (const name of colors) {
         if (isAlphaColor(name)) {
@@ -65,7 +72,7 @@ export function buildOutputFiles(config) {
     }
     if (accents) {
         const colorNames = colors.filter((c) => !isAlphaColor(c));
-        files.push(accentsFile(colorNames, outputPath));
+        files.push(accentsFile(colorNames, grays, outputPath));
     }
     if (tailwind) {
         const tailwindNames = colors.map((c) => c === 'blackAlpha' ? 'black' : c === 'whiteAlpha' ? 'white' : c);
@@ -104,7 +111,11 @@ export function writeOutputFiles(files) {
             return { path: file.path, status: 'written' };
         }
         catch (error) {
-            return { path: file.path, status: 'error', error: error };
+            return {
+                path: file.path,
+                status: 'error',
+                error: error,
+            };
         }
     });
 }

package/dist/cli/utils.d.ts

@@ -1,14 +1,5 @@
 export declare const alphaColors: readonly ["blackAlpha", "whiteAlpha"];
 export type AlphaColor = (typeof alphaColors)[number];
-/**
- * get package.json content from startDir
- * @param cwd
- * @returns package.json content
- */
-export declare const getPackageJson: (cwd: string) => {
-    pkg: any;
-    packageJsonPath: string;
-} | undefined;
 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,50 +1,6 @@
-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 {} from "../types.js";
 export const alphaColors = ['blackAlpha', 'whiteAlpha'];
-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;
-    }
-};
 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/dist/css.d.ts

@@ -12,7 +12,7 @@ type PaletteOptions = {
 declare function palette<C extends Color>(config: PaletteColor<C>, options?: PaletteOptions): string;
 declare function alpha(config: AlphaConfig): string;
 declare function accents(colorNames: string[]): string;
-declare function grays(names: readonly string[], className: string): string;
+declare function grays(names: readonly string[], className?: string): string;
 type TailwindOptions = {
     /** Include @import for accents.css. Defaults to false */
     accents?: boolean;

package/dist/css.js

@@ -80,7 +80,7 @@ function accents(colorNames) {
     output.push(formatRule(`[data-accent-color]:where(:not([data-accent-color=''], [data-accent-color='gray']))`, [...focus, ...focusAlpha]));
     return output.join('\n\n') + '\n';
 }
-function grays(names, className) {
+function grays(names, className = 'diskette-palette') {
     const grays = names.filter((n) => n !== 'gray');
     const blocks = grays.map((colorName) => {
         const srgb = [];

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 export declare const grayColors: readonly ["gray", "mauve", "slate", "sage", "olive", "sand"];
 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 declare const accentColors: readonly ["gray", "tomato", "red", "ruby", "crimson", "pink", "plum", "purple", "violet", "iris", "indigo", "blue", "cyan", "teal", "jade", "green", "grass", "bronze", "gold", "brown", "orange", "amber", "yellow", "lime", "mint", "sky"];
 export type AccentColor = (typeof accentColors)[number];
 export type Color = AccentColor | GrayColor;
 type Tuple<T, N extends number, R extends T[] = []> = R['length'] extends N ? R : Tuple<T, N, [...R, T]>;

package/dist/types.js

@@ -8,12 +8,6 @@ export const grayColors = [
 ];
 export const accentColors = [
     'gray',
-    'gold',
-    'bronze',
-    'brown',
-    'yellow',
-    'amber',
-    'orange',
     'tomato',
     'red',
     'ruby',
@@ -30,6 +24,12 @@ export const accentColors = [
     'jade',
     'green',
     'grass',
+    'bronze',
+    'gold',
+    'brown',
+    'orange',
+    'amber',
+    'yellow',
     'lime',
     'mint',
     'sky',

package/package.json

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