@dicebear/core 10.0.0-rc.5 → 10.0.1

package/lib/Options.d.ts

@@ -26,12 +26,11 @@ export declare class Options<D = unknown> {
     translateX(): Range | undefined;
     translateY(): Range | undefined;
     /**
-     * Returns the user-set variant constraint for `name`:
-     * - `undefined` when the user did not set `${name}Variant`,
-     * - `string[]` when the user gave a string or string list (each weighted 1),
-     * - `Record<string, number>` when the user gave a weighted map.
+     * Returns the user-set variant constraint for `name` as a weighted map, or
+     * `undefined` when `${name}Variant` is unset. A bare string or string list
+     * is normalized to a map with each entry weighted `1`.
      */
-    componentVariant(name: string): readonly string[] | Readonly<Record<string, number>> | undefined;
+    componentVariant(name: string): Readonly<Record<string, number>> | undefined;
     componentProbability(name: string): number | undefined;
     /**
      * Asymmetric on purpose: returns `undefined` (rather than `[]`) when

package/lib/Options.js

@@ -65,18 +65,20 @@ export class Options {
         return __classPrivateFieldGet(this, _Options_instances, "m", _Options_toRange).call(this, __classPrivateFieldGet(this, _Options_data, "f").translateY);
     }
     /**
-     * Returns the user-set variant constraint for `name`:
-     * - `undefined` when the user did not set `${name}Variant`,
-     * - `string[]` when the user gave a string or string list (each weighted 1),
-     * - `Record<string, number>` when the user gave a weighted map.
+     * Returns the user-set variant constraint for `name` as a weighted map, or
+     * `undefined` when `${name}Variant` is unset. A bare string or string list
+     * is normalized to a map with each entry weighted `1`.
      */
     componentVariant(name) {
         const raw = __classPrivateFieldGet(this, _Options_instances, "m", _Options_dynamic).call(this, `${name}Variant`);
         if (raw === undefined) {
             return undefined;
         }
-        if (typeof raw === 'string' || Array.isArray(raw)) {
-            return __classPrivateFieldGet(this, _Options_instances, "m", _Options_asArray).call(this, raw);
+        if (typeof raw === 'string') {
+            return { [raw]: 1 };
+        }
+        if (Array.isArray(raw)) {
+            return Object.fromEntries(raw.map((v) => [v, 1]));
         }
         return raw;
     }

package/lib/OptionsDescriptor.d.ts

@@ -21,6 +21,7 @@ interface EnumField {
 interface ColorField {
     readonly type: 'color';
     readonly list?: true;
+    readonly contrastTo?: string;
 }
 interface RangeField {
     readonly type: 'range';

package/lib/OptionsDescriptor.js

@@ -63,7 +63,12 @@ _a = OptionsDescriptor, _OptionsDescriptor_descriptor = new WeakMap(), _OptionsD
         result[`${name}Probability`] = { type: 'number', min: 0, max: 100 };
     }
     for (const name of [...__classPrivateFieldGet(this, _OptionsDescriptor_style, "f").colors().keys(), 'background']) {
-        result[`${name}Color`] = { type: 'color', list: true };
+        const contrastTo = __classPrivateFieldGet(this, _OptionsDescriptor_style, "f").colors().get(name)?.contrastTo();
+        result[`${name}Color`] = {
+            type: 'color',
+            list: true,
+            ...(contrastTo ? { contrastTo } : {}),
+        };
         result[`${name}ColorFill`] = {
             type: 'enum',
             values: ['solid', 'linear', 'radial'],

package/lib/Prng.d.ts

@@ -17,13 +17,11 @@ export declare class Prng {
      */
     pick<T>(key: string, items: readonly T[]): T | undefined;
     /**
-     * Picks an item from `entries` proportional to its weight. Duplicate items
-     * (by string representation) are collapsed before picking — only the
-     * first occurrence's weight is kept. When all weights are zero, falls
-     * back to an unweighted {@link pick}. Returns `undefined` for an empty
-     * list.
+     * Picks a key from `weights` proportional to its weight. When all weights
+     * are zero, falls back to an unweighted {@link pick}. Returns `undefined`
+     * for an empty map.
      */
-    weightedPick<T>(key: string, entries: readonly (readonly [T, number])[]): T | undefined;
+    weightedPick(key: string, weights: Readonly<Record<string, number>>): string | undefined;
     /**
      * Returns `true` with the given probability (0–100, default 50).
      */

package/lib/Prng.js

@@ -47,34 +47,32 @@ export class Prng {
         return sorted[index];
     }
     /**
-     * Picks an item from `entries` proportional to its weight. Duplicate items
-     * (by string representation) are collapsed before picking — only the
-     * first occurrence's weight is kept. When all weights are zero, falls
-     * back to an unweighted {@link pick}. Returns `undefined` for an empty
-     * list.
+     * Picks a key from `weights` proportional to its weight. When all weights
+     * are zero, falls back to an unweighted {@link pick}. Returns `undefined`
+     * for an empty map.
      */
-    weightedPick(key, entries) {
-        if (entries.length === 0) {
+    weightedPick(key, weights) {
+        const keys = Object.keys(weights);
+        if (keys.length === 0) {
             return undefined;
         }
-        if (entries.length === 1) {
-            return entries[0][0];
+        if (keys.length === 1) {
+            return keys[0];
         }
-        const unique = __classPrivateFieldGet(this, _Prng_instances, "m", _Prng_uniqueByCodePoint).call(this, entries, (e) => String(e[0]));
-        const sorted = unique.sort((a, b) => __classPrivateFieldGet(this, _Prng_instances, "m", _Prng_compareByCodePoint).call(this, a[0], b[0]));
-        const totalWeight = sorted.reduce((sum, e) => sum + e[1], 0);
+        const sorted = keys.sort(__classPrivateFieldGet(this, _Prng_instances, "m", _Prng_compareByCodePoint));
+        const totalWeight = sorted.reduce((sum, k) => sum + weights[k], 0);
         if (totalWeight === 0) {
-            return this.pick(key, sorted.map((e) => e[0]));
+            return this.pick(key, sorted);
         }
         const threshold = this.getValue(key) * totalWeight;
         let cumulative = 0;
-        for (const [item, weight] of sorted) {
-            cumulative += weight;
+        for (const k of sorted) {
+            cumulative += weights[k];
             if (threshold < cumulative) {
-                return item;
+                return k;
             }
         }
-        return sorted[sorted.length - 1][0];
+        return sorted[sorted.length - 1];
     }
     /**
      * Returns `true` with the given probability (0–100, default 50).

package/lib/Resolver.d.ts

@@ -30,8 +30,9 @@ export declare class Resolver<D = unknown> {
      * as `${name}Variant` in the input data:
      *
      * - `undefined`: PRNG picks from all style variants using their weights.
-     * - `string` or `string[]`: PRNG picks from the given subset (weight 1 each).
-     * - `Record<string, number>`: PRNG picks using the provided weights.
+     * - otherwise: PRNG picks using the user-supplied weighted map (a bare
+     *   string or string list is normalized to weight `1` each in
+     *   {@link Options.componentVariant}).
      *
      * Only variants that exist in the style definition are considered.
      */

package/lib/Resolver.js

@@ -78,8 +78,9 @@ export class Resolver {
      * as `${name}Variant` in the input data:
      *
      * - `undefined`: PRNG picks from all style variants using their weights.
-     * - `string` or `string[]`: PRNG picks from the given subset (weight 1 each).
-     * - `Record<string, number>`: PRNG picks using the provided weights.
+     * - otherwise: PRNG picks using the user-supplied weighted map (a bare
+     *   string or string list is normalized to weight `1` each in
+     *   {@link Options.componentVariant}).
      *
      * Only variants that exist in the style definition are considered.
      */
@@ -91,22 +92,20 @@ export class Resolver {
             }
             const raw = __classPrivateFieldGet(this, _Resolver_options, "f").componentVariant(component.sourceName());
             const variants = component.variants();
-            let entries;
+            const weights = {};
             if (raw === undefined) {
-                entries = Array.from(variants).map(([v, variant]) => [
-                    v,
-                    variant.weight(),
-                ]);
-            }
-            else if (Array.isArray(raw)) {
-                entries = raw
-                    .filter((v) => variants.has(v))
-                    .map((v) => [v, 1]);
+                for (const [v, variant] of variants) {
+                    weights[v] = variant.weight();
+                }
             }
             else {
-                entries = Object.entries(raw).filter(([v]) => variants.has(v));
+                for (const [v, w] of Object.entries(raw)) {
+                    if (variants.has(v)) {
+                        weights[v] = w;
+                    }
+                }
             }
-            return __classPrivateFieldGet(this, _Resolver_prng, "f").weightedPick(`${name}Variant`, entries);
+            return __classPrivateFieldGet(this, _Resolver_prng, "f").weightedPick(`${name}Variant`, weights);
         });
     }
     color(name) {

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export { Style, type StyleDefinition } from './Style.js';
 export { Avatar } from './Avatar.js';
+export { Color } from './Utils/Color.js';
 export { OptionsDescriptor } from './OptionsDescriptor.js';
 export type { StyleOptions } from './StyleOptions.js';

package/lib/index.js

@@ -1,3 +1,4 @@
 export { Style } from './Style.js';
 export { Avatar } from './Avatar.js';
+export { Color } from './Utils/Color.js';
 export { OptionsDescriptor } from './OptionsDescriptor.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dicebear/core",
-  "version": "10.0.0-rc.5",
+  "version": "10.0.1",
   "description": "Unique avatars from dozens of styles — deterministic, customizable, vector-based.",
   "keywords": [
     "avatar",