dicebear 5.0.0-alpha.26 → 5.0.0-alpha.29

package/lib/index.js

@@ -1,16 +1,16 @@
-import { Command } from 'commander';
 import updateNotifier from 'update-notifier';
 import * as collection from '@dicebear/collection';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
 import { getPackageJson } from './utils/getPackageJson.js';
-import { makeStyleCommand } from './command/makeStyleCommand.js';
+import { addStyleCommand } from './utils/addStyleCommand.js';
 (async () => {
     const pkg = await getPackageJson();
-    const program = new Command('dicebear');
     updateNotifier({ pkg }).notify();
-    program.version(pkg.version, '-v, --version');
+    const cli = yargs(hideBin(process.argv));
     for (let name of Object.keys(collection)) {
         const style = collection[name];
-        program.addCommand(await makeStyleCommand(name, style));
+        addStyleCommand(cli, name, style);
     }
-    await program.parseAsync(process.argv);
+    cli.demandCommand().help().locale('en').parse();
 })();

package/lib/utils/addStyleCommand.d.ts

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

package/lib/utils/addStyleCommand.js

@@ -0,0 +1,59 @@
+import { createAvatar } from '@dicebear/core';
+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';
+export function addStyleCommand(cli, name, style) {
+    const schema = getStyleCommandSchema(style);
+    return cli.command({
+        command: `${name} [outputPath]`,
+        describe: `Generate "${name}" avatar(s)`,
+        builder: (yargs) => {
+            return yargs
+                .default('outputPath', '.')
+                .options(getOptionsBySchema(schema));
+        },
+        handler: async (argv) => {
+            const bar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
+            const validated = validateInputBySchema(argv, schema);
+            const count = validated.count;
+            const includeExif = validated.exif;
+            outputStyleLicenseBanner(name, style);
+            bar.start(count, 0);
+            const queue = new PQueue({ concurrency: os.cpus().length });
+            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}.${validated.format}`);
+                    const avatar = createAvatar(style, validated);
+                    switch (validated.format) {
+                        case 'svg':
+                            await avatar.toFile(fileName);
+                            break;
+                        case 'png':
+                            await avatar.png({ includeExif }).toFile(fileName);
+                            break;
+                        case 'jpg':
+                        case 'jpeg':
+                            await avatar.jpeg({ includeExif }).toFile(fileName);
+                            break;
+                    }
+                    bar.increment();
+                });
+            }
+            await queue.onIdle();
+            bar.stop();
+            exiftool.end();
+        },
+    });
+}

package/lib/utils/getOptionsBySchema.d.ts

@@ -1,3 +1,2 @@
-import { Option } from 'commander';
 import { JSONSchema7 } from 'json-schema';
-export declare function getOptionsBySchema(schema: JSONSchema7): Promise<Option[]>;
+export declare function getOptionsBySchema(schema: JSONSchema7): Record<string, any>;

package/lib/utils/getOptionsBySchema.js

@@ -1,29 +1,39 @@
-import { Option } from 'commander';
-export async function getOptionsBySchema(schema) {
-    const result = [];
+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 = new Option(`--${key} <value>`);
-            let description = [property.title, property.description].filter((v) => v).join(' - ');
-            let choices = [];
+            const option = {
+                type: property.type,
+            };
+            if (option.type === 'integer') {
+                option.type = 'number';
+            }
+            option.choices = [];
             if (property.enum) {
-                choices.push(...property.enum.filter((v) => typeof v === 'string'));
+                option.choices.push(...property.enum.filter((v) => typeof v === 'string'));
             }
-            if (typeof property.items === 'object' && 'enum' in property.items && property.items.enum) {
-                choices.push(...property.items.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 (choices.length > 0) {
-                description += ` (choices: "${choices.join('", "')})`;
+            if (option.choices.length === 0) {
+                delete option.choices;
             }
             if (property.default !== undefined && property.default !== null) {
-                option.default(typeof property.default === 'boolean' ? property.default : property.default.toString());
+                option.default =
+                    typeof property.default === 'boolean'
+                        ? property.default
+                        : property.default;
+            }
+            if (property.description) {
+                option.description = property.description;
             }
-            option.description = description;
-            result.push(option);
+            result[key] = option;
         }
     }
     return result;

package/lib/utils/getStyleCommandSchema.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,30 @@
+import { schema as coreSchema } from '@dicebear/core';
+import mergeAllOf from 'json-schema-merge-allof';
+export function getStyleCommandSchema(style) {
+    return mergeAllOf({
+        allOf: [
+            {
+                properties: {
+                    count: {
+                        description: 'Defines how many avatars to create.',
+                        type: 'number',
+                        default: 1,
+                    },
+                    format: {
+                        type: 'string',
+                        enum: ['svg', 'png', 'jpg', 'jpeg'],
+                        default: 'svg',
+                    },
+                    exif: {
+                        description: 'Include Exif Metadata',
+                        type: 'boolean',
+                        default: false,
+                    },
+                },
+            },
+            coreSchema,
+            style.schema,
+        ],
+        additionalItems: true,
+    }, { ignoreAdditionalProperties: true });
+}

package/lib/utils/validateInputBySchema.d.ts

@@ -1,2 +1,3 @@
 import { JSONSchema7 } from 'json-schema';
-export declare function validateInputBySchema(input: Record<string, string | number>, schema: JSONSchema7): Record<string, string | number | boolean | string[] | number[] | boolean[]>;
+import { ArgumentsCamelCase } from 'yargs';
+export declare function validateInputBySchema(input: ArgumentsCamelCase<unknown>, schema: JSONSchema7): any;

package/lib/utils/validateInputBySchema.js

@@ -7,20 +7,7 @@ export function validateInputBySchema(input, schema) {
         removeAdditional: true,
     });
     const validate = validator.compile(schema);
-    const data = {};
-    for (var key in input) {
-        if (false === input.hasOwnProperty(key)) {
-            continue;
-        }
-        if (schema.properties && key in schema.properties) {
-            const property = schema.properties[key];
-            if (typeof property === 'object' && property.type === 'array') {
-                data[key] = input[key].toString().split(',');
-                continue;
-            }
-        }
-        data[key] = input[key];
-    }
+    const data = JSON.parse(JSON.stringify(input));
     if (false === validate(data)) {
         if (validate.errors) {
             for (var error of validate.errors) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dicebear",
-  "version": "5.0.0-alpha.26",
+  "version": "5.0.0-alpha.29",
   "private": false,
   "description": "CLI for DiceBear - An avatar library for designers and developers",
   "homepage": "https://github.com/dicebear/dicebear",
@@ -25,20 +25,20 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@dicebear/collection": "^5.0.0-alpha.26",
-    "@dicebear/core": "^5.0.0-alpha.26",
-    "@resvg/resvg-js": "^1.4.0",
+    "@dicebear/collection": "^5.0.0-alpha.29",
+    "@dicebear/core": "^5.0.0-alpha.29",
+    "@resvg/resvg-js": "^2.0.0",
     "ajv": "^8.11.0",
     "chalk": "^5.0.1",
     "chalk-template": "^0.4.0",
     "cli-progress": "^3.10.0",
-    "commander": "^9.2.0",
     "exiftool-vendored": "^16.3.0",
     "fs-extra": "^10.1.0",
     "json-schema-merge-allof": "^0.8.1",
     "p-queue": "^7.2.0",
     "sharp": "^0.30.4",
-    "update-notifier": "^5.1.0"
+    "update-notifier": "^5.1.0",
+    "yargs": "^17.4.1"
   },
   "devDependencies": {
     "@tsconfig/recommended": "^1.0.1",
@@ -47,11 +47,12 @@
     "@types/json-schema": "^7.0.11",
     "@types/json-schema-merge-allof": "^0.6.1",
     "@types/update-notifier": "^5.1.0",
+    "@types/yargs": "^17.0.10",
     "del-cli": "^4.0.1",
     "typescript": "^4.6.3"
   },
   "engines": {
     "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
   },
-  "gitHead": "68a91a6c5fa46dd8317fe066803657ac0bf59f68"
+  "gitHead": "775410bda059fa21dcb79b38c72ebadb80896243"
 }

package/lib/command/makeStyleCommand.d.ts

@@ -1,3 +0,0 @@
-import type { Style } from '@dicebear/core';
-import { Command } from 'commander';
-export declare function makeStyleCommand(name: string, style: Style<any>): Promise<Command>;

package/lib/command/makeStyleCommand.js

@@ -1,84 +0,0 @@
-import { createAvatar, schema as coreSchema } from '@dicebear/core';
-import { Command } from 'commander';
-import * as path from 'node:path';
-import fs from 'fs-extra';
-import cliProgress from 'cli-progress';
-import { validateInputBySchema } from '../utils/validateInputBySchema.js';
-import { outputStyleLicenseBanner } from '../utils/outputStyleLicenseBanner.js';
-import { getOptionsBySchema } from '../utils/getOptionsBySchema.js';
-import mergeAllOf from 'json-schema-merge-allof';
-import PQueue from 'p-queue';
-import os from 'node:os';
-import { exiftool } from 'exiftool-vendored';
-export async function makeStyleCommand(name, style) {
-    const schema = mergeAllOf({
-        allOf: [
-            {
-                properties: {
-                    count: {
-                        title: 'Count',
-                        description: 'Defines how many avatars to create. Does not work in combination with a "seed".',
-                        type: 'number',
-                        default: 1,
-                    },
-                    format: {
-                        title: 'Format',
-                        type: 'string',
-                        enum: ['svg', 'png', 'jpg', 'jpeg'],
-                        default: 'svg',
-                    },
-                    exif: {
-                        title: 'Include Exif Metadata',
-                        type: 'boolean',
-                        default: false,
-                    },
-                },
-            },
-            coreSchema,
-            style.schema,
-        ],
-        additionalItems: true,
-    }, { ignoreAdditionalProperties: true });
-    const cmd = new Command(name);
-    cmd.arguments('[outputPath]');
-    for (let option of await getOptionsBySchema(schema)) {
-        cmd.addOption(option);
-    }
-    cmd.action(async (outputPath = '.', options = {}) => {
-        const bar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic);
-        const validated = validateInputBySchema(options, schema);
-        const count = validated.count;
-        const includeExif = validated.exif;
-        outputStyleLicenseBanner(name, style);
-        bar.start(count, 0);
-        const queue = new PQueue({ concurrency: os.cpus().length });
-        queue.on('next', () => {
-            bar.update(count - queue.size - queue.pending);
-        });
-        outputPath = path.resolve(process.cwd(), outputPath);
-        await fs.ensureDir(outputPath);
-        for (let i = 0; i < count; i++) {
-            queue.add(async () => {
-                const fileName = path.resolve(process.cwd(), outputPath, `${name}-${i}.${validated.format}`);
-                const avatar = createAvatar(style, validated);
-                switch (validated.format) {
-                    case 'svg':
-                        await avatar.toFile(fileName);
-                        break;
-                    case 'png':
-                        await avatar.png({ includeExif }).toFile(fileName);
-                        break;
-                    case 'jpg':
-                    case 'jpeg':
-                        await avatar.jpeg({ includeExif }).toFile(fileName);
-                        break;
-                }
-                bar.increment();
-            });
-        }
-        await queue.onIdle();
-        bar.stop();
-        exiftool.end();
-    });
-    return cmd;
-}