dicebear 9.4.2 → 10.0.0-rc.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Florian Körner
+Copyright (c) 2026 Florian Körner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/index.js

@@ -1,16 +1,54 @@
 import updateNotifier from 'update-notifier';
-import * as collection from '@dicebear/collection';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import chalk from 'chalk';
 import { getPackageJson } from './utils/getPackageJson.js';
 import { addStyleCommand } from './utils/addStyleCommand.js';
+import { loadStyles } from './utils/loadStyles.js';
+import { loadDefinition } from './utils/loadDefinition.js';
+import { handleStyleCommand } from './utils/handleStyleCommand.js';
+import { getStyleCommandOptions } from './utils/getStyleCommandOptions.js';
 (async () => {
     const pkg = await getPackageJson();
     updateNotifier({ pkg }).notify();
     const cli = yargs(hideBin(process.argv));
-    for (let name of Object.keys(collection)) {
-        const style = collection[name];
+    const styles = loadStyles();
+    for (const [name, style] of styles) {
         addStyleCommand(cli, name, style);
     }
+    cli.command({
+        command: '* <definition> [outputPath]',
+        describe: false,
+        builder: (yargs) => {
+            const args = hideBin(process.argv);
+            const filePath = args[0];
+            let options = {};
+            if (filePath) {
+                try {
+                    const { style } = loadDefinition(filePath);
+                    options = getStyleCommandOptions(style);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error(chalk.red(`\nError: ${message}`));
+                    process.exit(1);
+                }
+            }
+            return yargs
+                .default('outputPath', '.')
+                .options(options);
+        },
+        handler: async (argv) => {
+            try {
+                const { style, name } = loadDefinition(argv.definition);
+                await handleStyleCommand(argv, name, style);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(chalk.red(`\nError: ${message}`));
+                process.exit(1);
+            }
+        },
+    });
     cli.demandCommand().help().locale('en').parse();
 })();

package/lib/utils/addStyleCommand.d.ts

@@ -1,3 +1,3 @@
 import type { Style } from '@dicebear/core';
 import yargs from 'yargs';
-export declare function addStyleCommand(cli: yargs.Argv<{}>, name: string, style: Style<any>): yargs.Argv<{}>;
+export declare function addStyleCommand(cli: yargs.Argv<{}>, name: string, style: Style): yargs.Argv<{}>;

package/lib/utils/addStyleCommand.js

@@ -1,91 +1,25 @@
-import { createAvatar } from '@dicebear/core';
-import { toJpeg, toPng, toWebp, toAvif } from '@dicebear/converter';
-import cliProgress from 'cli-progress';
-import PQueue from 'p-queue';
-import os from 'node:os';
-import * as path from 'node:path';
-import fs from 'fs-extra';
-import { exiftool } from 'exiftool-vendored';
-import { getStyleCommandSchema } from './getStyleCommandSchema.js';
-import { getOptionsBySchema } from './getOptionsBySchema.js';
-import { validateInputBySchema } from './validateInputBySchema.js';
-import { outputStyleLicenseBanner } from './outputStyleLicenseBanner.js';
-import { createRandomSeed } from './createRandomSeed.js';
-import { writeFile } from './writeFile.js';
+import chalk from 'chalk';
+import { getStyleCommandOptions } from './getStyleCommandOptions.js';
+import { handleStyleCommand } from './handleStyleCommand.js';
 export function addStyleCommand(cli, name, style) {
-    const schema = getStyleCommandSchema(style);
+    const options = getStyleCommandOptions(style);
     return cli.command({
         command: `${name} [outputPath]`,
         describe: `Generate "${name}" avatar(s)`,
         builder: (yargs) => {
             return yargs
                 .default('outputPath', '.')
-                .options(getOptionsBySchema(schema));
+                .options(options);
         },
         handler: async (argv) => {
-            const bar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
-            const validated = validateInputBySchema(argv, schema);
-            const format = validated.format;
-            const count = validated.count;
-            const includeExif = validated.exif;
-            const json = validated.json;
-            outputStyleLicenseBanner(name, style);
-            bar.start(count, 0);
-            const queue = new PQueue({ concurrency: os.cpus().length || 1 });
-            queue.on('next', () => {
-                bar.update(count - queue.size - queue.pending);
-            });
-            const outputPath = path.resolve(process.cwd(), argv.outputPath);
-            await fs.ensureDir(outputPath);
-            for (let i = 0; i < count; i++) {
-                queue.add(async () => {
-                    const fileName = path.resolve(process.cwd(), outputPath, `${name}-${i}.${format}`);
-                    const avatar = createAvatar(style, count <= 1
-                        ? validated
-                        : {
-                            ...validated,
-                            seed: createRandomSeed(),
-                        });
-                    switch (format) {
-                        case 'svg':
-                            await writeFile(fileName, avatar.toString());
-                            break;
-                        case 'png':
-                            await writeFile(fileName, await toPng(avatar.toString(), { includeExif, size: validated.size }).toArrayBuffer());
-                            break;
-                        case 'jpg':
-                        case 'jpeg':
-                            await writeFile(fileName, await toJpeg(avatar.toString(), {
-                                includeExif,
-                                size: validated.size,
-                            }).toArrayBuffer());
-                            break;
-                        case 'webp':
-                            await writeFile(fileName, await toWebp(avatar.toString(), {
-                                includeExif,
-                                size: validated.size,
-                            }).toArrayBuffer());
-                            break;
-                        case 'avif':
-                            await writeFile(fileName, await toAvif(avatar.toString(), {
-                                includeExif,
-                                size: validated.size,
-                            }).toArrayBuffer());
-                            break;
-                        case 'json':
-                            await writeFile(fileName, JSON.stringify(avatar.toJson(), null, 2));
-                            break;
-                    }
-                    if (json && 'json' !== format) {
-                        const jsonFileName = path.resolve(process.cwd(), outputPath, `${name}-${i}.json`);
-                        await fs.writeJSON(jsonFileName, avatar.toJson(), { spaces: 2 });
-                    }
-                    bar.increment();
-                });
+            try {
+                await handleStyleCommand(argv, name, style);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(chalk.red(`\nError: ${message}`));
+                process.exit(1);
             }
-            await queue.onIdle();
-            bar.stop();
-            exiftool.end();
         },
     });
 }

package/lib/utils/extractStyleOptions.d.ts

@@ -0,0 +1,2 @@
+import { Style } from '@dicebear/core';
+export declare function extractStyleOptions(argv: Record<string, unknown>, style: Style): Record<string, unknown>;

package/lib/utils/extractStyleOptions.js

@@ -0,0 +1,42 @@
+import { OptionsDescriptor } from '@dicebear/core';
+// Parses ['variant01:2', 'variant03:1'] (array from yargs) into { variant01: 2, variant03: 1 }
+function parseWeightedValue(value) {
+    const result = {};
+    for (const pair of value) {
+        const [key, weight] = pair.split(':');
+        if (key) {
+            result[key.trim()] = weight !== undefined ? Number(weight) : 1;
+        }
+    }
+    return result;
+}
+// Parses "10,50" into [10, 50] for range values
+function parseRangeValue(value) {
+    if (typeof value === 'string' && value.includes(',')) {
+        const parts = value.split(',').map(Number);
+        if (parts.length === 2 && parts.every((n) => !isNaN(n))) {
+            return parts;
+        }
+    }
+    return value;
+}
+// Extracts only the style-relevant options from the yargs argv object,
+// filtering out CLI-specific keys (_, $0, outputPath, count, format, etc.).
+export function extractStyleOptions(argv, style) {
+    const descriptor = new OptionsDescriptor(style).toJSON();
+    const result = {};
+    for (const [key, field] of Object.entries(descriptor)) {
+        if (!(key in argv) || argv[key] === undefined) {
+            continue;
+        }
+        let value = argv[key];
+        if (field.type === 'enum' && field.weighted && Array.isArray(value)) {
+            value = parseWeightedValue(value);
+        }
+        if (field.type === 'range') {
+            value = parseRangeValue(value);
+        }
+        result[key] = value;
+    }
+    return result;
+}

package/lib/utils/getStyleCommandOptions.d.ts

@@ -0,0 +1,3 @@
+import { Style } from '@dicebear/core';
+import type { Options } from 'yargs';
+export declare function getStyleCommandOptions(style: Style): Record<string, Options>;

package/lib/utils/getStyleCommandOptions.js

@@ -0,0 +1,54 @@
+import { OptionsDescriptor } from '@dicebear/core';
+export function getStyleCommandOptions(style) {
+    const descriptor = new OptionsDescriptor(style).toJSON();
+    const result = {
+        count: {
+            description: 'Defines how many avatars to create.',
+            type: 'number',
+            default: 1,
+        },
+        format: {
+            type: 'string',
+            choices: ['svg', 'png', 'jpg', 'jpeg', 'webp', 'avif', 'json'],
+            default: 'svg',
+        },
+        exif: {
+            description: 'Include Exif Metadata',
+            type: 'boolean',
+            default: false,
+        },
+        json: {
+            description: 'Save JSON file in addition to image file',
+            type: 'boolean',
+            default: false,
+        },
+    };
+    for (const [key, field] of Object.entries(descriptor)) {
+        const option = {};
+        switch (field.type) {
+            case 'string':
+                option.type = 'string';
+                break;
+            case 'number':
+                option.type = 'number';
+                break;
+            case 'range':
+                option.type = 'string';
+                break;
+            case 'boolean':
+                option.type = 'boolean';
+                break;
+            case 'enum':
+                option.type = 'string';
+                if (!field.weighted) {
+                    option.choices = field.values;
+                }
+                break;
+            case 'color':
+                option.type = 'string';
+                break;
+        }
+        result[key] = option;
+    }
+    return result;
+}

package/lib/utils/handleStyleCommand.d.ts

@@ -0,0 +1,3 @@
+import { Style } from '@dicebear/core';
+import type { ArgumentsCamelCase } from 'yargs';
+export declare function handleStyleCommand(argv: ArgumentsCamelCase<{}>, name: string, style: Style): Promise<void>;

package/lib/utils/handleStyleCommand.js

@@ -0,0 +1,88 @@
+import { Avatar } from '@dicebear/core';
+import { toJpeg, toPng, toWebp, toAvif } from '@dicebear/converter';
+import cliProgress from 'cli-progress';
+import PQueue from 'p-queue';
+import os from 'node:os';
+import * as path from 'node:path';
+import fs from 'fs-extra';
+import { exiftool } from 'exiftool-vendored';
+import { extractStyleOptions } from './extractStyleOptions.js';
+import { outputStyleLicenseBanner } from './outputStyleLicenseBanner.js';
+import { createRandomSeed } from './createRandomSeed.js';
+import { writeFile } from './writeFile.js';
+export async function handleStyleCommand(argv, name, style) {
+    var _a, _b, _c, _d;
+    const bar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
+    const format = (_a = argv.format) !== null && _a !== void 0 ? _a : 'svg';
+    const count = (_b = argv.count) !== null && _b !== void 0 ? _b : 1;
+    const includeExif = (_c = argv.exif) !== null && _c !== void 0 ? _c : false;
+    const json = (_d = argv.json) !== null && _d !== void 0 ? _d : false;
+    outputStyleLicenseBanner(name, style);
+    bar.start(count, 0);
+    const queue = new PQueue({ concurrency: os.cpus().length || 1 });
+    const errors = [];
+    queue.on('next', () => {
+        bar.update(count - queue.size - queue.pending);
+    });
+    const outputPath = path.resolve(process.cwd(), argv.outputPath);
+    await fs.ensureDir(outputPath);
+    for (let i = 0; i < count; i++) {
+        queue.add(async () => {
+            var _a;
+            try {
+                const fileName = path.resolve(process.cwd(), outputPath, `${name}-${i}.${format}`);
+                const seed = count <= 1
+                    ? (_a = argv.seed) !== null && _a !== void 0 ? _a : createRandomSeed()
+                    : createRandomSeed();
+                const avatar = new Avatar(style, {
+                    ...extractStyleOptions(argv, style),
+                    seed,
+                });
+                switch (format) {
+                    case 'svg':
+                        await writeFile(fileName, avatar.toString());
+                        break;
+                    case 'png':
+                        await writeFile(fileName, await toPng(avatar.toString(), { includeExif, size: argv.size }).toArrayBuffer());
+                        break;
+                    case 'jpg':
+                    case 'jpeg':
+                        await writeFile(fileName, await toJpeg(avatar.toString(), {
+                            includeExif,
+                            size: argv.size,
+                        }).toArrayBuffer());
+                        break;
+                    case 'webp':
+                        await writeFile(fileName, await toWebp(avatar.toString(), {
+                            includeExif,
+                            size: argv.size,
+                        }).toArrayBuffer());
+                        break;
+                    case 'avif':
+                        await writeFile(fileName, await toAvif(avatar.toString(), {
+                            includeExif,
+                            size: argv.size,
+                        }).toArrayBuffer());
+                        break;
+                    case 'json':
+                        await writeFile(fileName, JSON.stringify(avatar.toJSON(), null, 2));
+                        break;
+                }
+                if (json && 'json' !== format) {
+                    const jsonFileName = path.resolve(process.cwd(), outputPath, `${name}-${i}.json`);
+                    await fs.writeJSON(jsonFileName, avatar.toJSON(), { spaces: 2 });
+                }
+                bar.increment();
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    await queue.onIdle();
+    bar.stop();
+    exiftool.end();
+    if (errors.length > 0) {
+        throw errors[0];
+    }
+}

package/lib/utils/loadDefinition.d.ts

@@ -0,0 +1,5 @@
+import { Style } from '@dicebear/core';
+export declare function loadDefinition(filePath: string): {
+    style: Style;
+    name: string;
+};

package/lib/utils/loadDefinition.js

@@ -0,0 +1,10 @@
+import { Style } from '@dicebear/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function loadDefinition(filePath) {
+    const definitionPath = path.resolve(process.cwd(), filePath);
+    const definition = JSON.parse(fs.readFileSync(definitionPath, 'utf-8'));
+    const style = new Style(definition);
+    const name = path.basename(definitionPath, path.extname(definitionPath));
+    return { style, name };
+}

package/lib/utils/loadStyles.d.ts

@@ -0,0 +1,2 @@
+import { Style } from '@dicebear/core';
+export declare function loadStyles(): Map<string, Style>;

package/lib/utils/loadStyles.js

@@ -0,0 +1,18 @@
+import { Style } from '@dicebear/core';
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+const require = createRequire(import.meta.url);
+export function loadStyles() {
+    const definitionsDir = path.dirname(require.resolve('@dicebear/definitions/initials.json'));
+    const styles = new Map();
+    for (const file of fs.readdirSync(definitionsDir)) {
+        if (!file.endsWith('.min.json')) {
+            continue;
+        }
+        const name = file.replace('.min.json', '');
+        const definition = JSON.parse(fs.readFileSync(path.join(definitionsDir, file), 'utf-8'));
+        styles.set(name, new Style(definition));
+    }
+    return styles;
+}

package/lib/utils/outputStyleLicenseBanner.d.ts

@@ -1,2 +1,2 @@
 import type { Style } from '@dicebear/core';
-export declare function outputStyleLicenseBanner(name: string, style: Style<any>): void;
+export declare function outputStyleLicenseBanner(name: string, style: Style): void;

package/lib/utils/outputStyleLicenseBanner.js

@@ -1,29 +1,28 @@
 import chalk from 'chalk';
 import chalkTemplate from 'chalk-template';
 export function outputStyleLicenseBanner(name, style) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    let banner = ['-'.repeat(64)];
-    let creator = Array.isArray((_a = style.meta) === null || _a === void 0 ? void 0 : _a.creator)
-        ? (_b = style.meta) === null || _b === void 0 ? void 0 : _b.creator.join(', ')
-        : (_c = style.meta) === null || _c === void 0 ? void 0 : _c.creator;
-    if (((_d = style.meta) === null || _d === void 0 ? void 0 : _d.title) && creator) {
-        banner.push(chalkTemplate `{bold ${style.meta.title}} by {bold ${creator}}`);
+    const meta = style.meta();
+    const sourceName = meta.source().name();
+    const creatorName = meta.creator().name();
+    const sourceUrl = meta.source().url();
+    const licenseName = meta.license().name();
+    const licenseUrl = meta.license().url();
+    const banner = ['-'.repeat(64)];
+    if (sourceName && creatorName) {
+        banner.push(chalkTemplate `{bold ${sourceName}} by {bold ${creatorName}}`);
     }
-    else if ((_e = style.meta) === null || _e === void 0 ? void 0 : _e.title) {
-        banner.push(chalkTemplate `{bold ${style.meta.title}}`);
+    else if (sourceName) {
+        banner.push(chalkTemplate `{bold ${sourceName}}`);
     }
-    else if (creator) {
-        banner.push(chalkTemplate `{bold ${name}} by {bold ${creator}}`);
+    else if (creatorName) {
+        banner.push(chalkTemplate `{bold ${name}} by {bold ${creatorName}}`);
     }
     banner.push('');
-    if ((_f = style.meta) === null || _f === void 0 ? void 0 : _f.homepage) {
-        banner.push(`Homepage: ${style.meta.homepage}`);
+    if (sourceUrl) {
+        banner.push(`Source: ${sourceUrl}`);
     }
-    if ((_g = style.meta) === null || _g === void 0 ? void 0 : _g.source) {
-        banner.push(`Source: ${style.meta.source}`);
-    }
-    if ((_h = style.meta) === null || _h === void 0 ? void 0 : _h.license) {
-        banner.push(`License: ${style.meta.license.name} - ${style.meta.license.url}`);
+    if (licenseName) {
+        banner.push(`License: ${licenseName}${licenseUrl ? ` - ${licenseUrl}` : ''}`);
     }
     banner.push('-'.repeat(64));
     banner.push('');

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dicebear",
-  "version": "9.4.2",
+  "version": "10.0.0-rc.1",
   "private": false,
-  "description": "CLI for DiceBear - An avatar library for designers and developers",
+  "description": "CLI for DiceBear — unique avatars from dozens of styles.",
   "homepage": "https://github.com/dicebear/dicebear",
   "repository": {
     "type": "git",
@@ -25,9 +25,9 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@dicebear/collection": "9.4.2",
-    "@dicebear/converter": "9.4.2",
-    "@dicebear/core": "9.4.2",
+    "@dicebear/converter": "10.0.0-rc.1",
+    "@dicebear/core": "10.0.0-rc.1",
+    "@dicebear/definitions": "^0.1.0",
     "ajv": "^8.17.1",
     "chalk": "^5.4.1",
     "chalk-template": "^1.1.2",

package/lib/utils/getOptionsBySchema.d.ts

@@ -1,2 +0,0 @@
-import { JSONSchema7 } from 'json-schema';
-export declare function getOptionsBySchema(schema: JSONSchema7): Record<string, any>;

package/lib/utils/getOptionsBySchema.js

@@ -1,34 +0,0 @@
-export function getOptionsBySchema(schema) {
-    const result = {};
-    for (var key in schema.properties) {
-        if (false === schema.properties.hasOwnProperty(key)) {
-            continue;
-        }
-        const property = schema.properties[key];
-        if (typeof property === 'object') {
-            const option = {
-                type: property.type,
-            };
-            if (option.type === 'integer') {
-                option.type = 'number';
-            }
-            option.choices = [];
-            if (property.enum) {
-                option.choices.push(...property.enum.filter((v) => typeof v === 'string'));
-            }
-            if (typeof property.items === 'object' &&
-                'enum' in property.items &&
-                property.items.enum) {
-                option.choices.push(...property.items.enum.filter((v) => typeof v === 'string'));
-            }
-            if (option.choices.length === 0) {
-                delete option.choices;
-            }
-            if (property.description) {
-                option.description = property.description;
-            }
-            result[key] = option;
-        }
-    }
-    return result;
-}

package/lib/utils/getStyleCommandSchema.d.ts

@@ -1,3 +0,0 @@
-import type { Style } from '@dicebear/core';
-import type { JSONSchema7 } from 'json-schema';
-export declare function getStyleCommandSchema(style: Style<any>): JSONSchema7;

package/lib/utils/getStyleCommandSchema.js

@@ -1,32 +0,0 @@
-import { schema as coreSchema } from '@dicebear/core';
-export function getStyleCommandSchema(style) {
-    var _a;
-    return {
-        $schema: 'http://json-schema.org/draft-07/schema#',
-        type: 'object',
-        properties: {
-            count: {
-                description: 'Defines how many avatars to create.',
-                type: 'number',
-                default: 1,
-            },
-            format: {
-                type: 'string',
-                enum: ['svg', 'png', 'jpg', 'jpeg', 'webp', 'avif', 'json'],
-                default: 'svg',
-            },
-            exif: {
-                description: 'Include Exif Metadata',
-                type: 'boolean',
-                default: false,
-            },
-            json: {
-                description: 'Save JSON file in addition to image file',
-                type: 'boolean',
-                default: false,
-            },
-            ...coreSchema.properties,
-            ...(_a = style.schema) === null || _a === void 0 ? void 0 : _a.properties,
-        },
-    };
-}

package/lib/utils/validateInputBySchema.d.ts

@@ -1,5 +0,0 @@
-import { JSONSchema7 } from 'json-schema';
-import { ArgumentsCamelCase } from 'yargs';
-export declare function validateInputBySchema(input: ArgumentsCamelCase<unknown>, schema: JSONSchema7): {
-    [x: string]: {};
-};

package/lib/utils/validateInputBySchema.js

@@ -1,20 +0,0 @@
-import Ajv from 'ajv';
-export function validateInputBySchema(input, schema) {
-    const validator = new Ajv({
-        strict: false,
-        coerceTypes: true,
-        useDefaults: true,
-        removeAdditional: 'all',
-    });
-    const validate = validator.compile(schema);
-    const data = JSON.parse(JSON.stringify(input));
-    if (false === validate(data)) {
-        if (validate.errors) {
-            for (var error of validate.errors) {
-                throw new Error(`${error.keyword} - ${error.message}`);
-            }
-        }
-        throw new Error('Unknown error');
-    }
-    return data;
-}