@urbicon-ui/blocks 6.33.0 → 6.34.0

package/dist/i18n/index.d.ts

@@ -379,7 +379,195 @@ declare const blocksTranslations: {
         };
     };
 };
-export declare const blocksI18n: import("@urbicon-ui/i18n").PackageI18n<import("@urbicon-ui/i18n").Translations>;
+export declare const blocksI18n: import("@urbicon-ui/i18n").PackageI18n<{
+    readonly accessibility: {
+        readonly avatar: "Avatar";
+        readonly breadcrumb: "Breadcrumb";
+        readonly breadcrumbExpand: "Show all breadcrumb items";
+        readonly clearInput: "Clear input";
+        readonly clearSearch: "Clear search";
+        readonly clearSelection: "Clear selection";
+        readonly closeDialog: "Close dialog";
+        readonly closeDrawer: "Close drawer";
+        readonly dismiss: "Dismiss";
+        readonly fileUpload: "File upload";
+        readonly loading: "Loading";
+        readonly maximum: "Maximum";
+        readonly minimum: "Minimum";
+        readonly pagination: "Page navigation";
+        readonly progress: "Progress";
+        readonly slider: "Slider";
+        readonly toggle: "Toggle";
+        readonly toggleOptions: "Toggle options";
+        readonly removableBadge: "Removable badge";
+        readonly removeBadge: "Remove badge";
+        readonly removeFile: "Remove {{name}}";
+        readonly removeTag: "Remove {{label}}";
+    };
+    readonly button: {
+        readonly close: "Close";
+        readonly apply: "Apply";
+        readonly cancel: "Cancel";
+        readonly confirm: "Confirm";
+    };
+    readonly menu: {
+        readonly placeholder: "Select an option...";
+    };
+    readonly common: {
+        readonly loading: "Loading...";
+    };
+    readonly languages: {
+        readonly de: "Deutsch";
+        readonly en: "English";
+        readonly es: "Español";
+        readonly fr: "Français";
+        readonly it: "Italiano";
+        readonly nl: "Nederlands";
+    };
+    readonly localeSwitcher: {
+        readonly ariaLabel: "Language selection";
+        readonly placeholder: "Select language...";
+    };
+    readonly pagination: {
+        readonly next: "Next";
+        readonly first: "First";
+        readonly last: "Last";
+        readonly page: "Page";
+        readonly previous: "Previous";
+        readonly pageInfo: "{{label}} {{current}} of {{total}}";
+        readonly rangeInfo: "{{start}}–{{end}} of {{total}}";
+    };
+    readonly calendar: {
+        readonly recurring: "Recurring event";
+        readonly previousMonth: "Previous month";
+        readonly nextMonth: "Next month";
+        readonly previousWeek: "Previous week";
+        readonly nextWeek: "Next week";
+        readonly previousDay: "Previous day";
+        readonly nextDay: "Next day";
+        readonly previousYear: "Previous year";
+        readonly nextYear: "Next year";
+        readonly today: "Today";
+        readonly calendarGrid: "Calendar";
+        readonly weekdays: "Weekdays";
+        readonly weekNumber: "Week number";
+        readonly events: "Events";
+        readonly noEvents: "No events";
+        readonly showMore: "{{count}} more";
+        readonly legend: "Legend";
+        readonly yearView: "Year overview";
+        readonly weekView: "Week view";
+        readonly viewMonth: "Month";
+        readonly viewYear: "Year";
+        readonly viewWeek: "Week";
+        readonly viewDay: "Day";
+        readonly multiDayLabel: "Day {{current}} of {{total}}";
+        readonly agendaView: "Agenda view";
+        readonly viewAgenda: "Agenda";
+        readonly viewSwitcher: "View mode";
+    };
+    readonly planner: {
+        readonly previousWeek: "Previous week";
+        readonly nextWeek: "Next week";
+        readonly previousMonth: "Previous month";
+        readonly nextMonth: "Next month";
+        readonly previousRange: "Previous range";
+        readonly nextRange: "Next range";
+        readonly today: "Today";
+        readonly grid: "Planner";
+        readonly itemCount: "{{count}} items";
+    };
+    readonly commandPalette: {
+        readonly noResults: "No results found.";
+        readonly search: "Search...";
+        readonly hints: {
+            readonly navigate: "Navigate";
+            readonly select: "Select";
+            readonly close: "Close";
+        };
+    };
+    readonly compositionBar: {
+        readonly total: "Total";
+        readonly summary: "Composition: {{total}} ({{count}} shares) — {{parts}}";
+        readonly share: "Share";
+        readonly value: "Value";
+        readonly percent: "Percent";
+        readonly remaining: "remaining";
+    };
+    readonly guide: {
+        readonly next: "Next";
+        readonly previous: "Back";
+        readonly skip: "Skip tour";
+        readonly done: "Done";
+        readonly step: "Step {{current}} of {{total}}";
+        readonly tour: "Guided tour";
+        readonly close: "Close";
+        readonly openHelp: "Help";
+        readonly backToList: "All topics";
+        readonly info: "More information";
+        readonly infoAbout: "More information about {{label}}";
+        readonly dismiss: "Dismiss hint";
+        readonly startTour: "Start the guided tour";
+        readonly actionRequired: "Complete the highlighted action to continue";
+        readonly filterPlaceholder: "Filter topics…";
+        readonly noResults: "No matching topics";
+    };
+    readonly journeyTimeline: {
+        readonly label: "Journey";
+        readonly status: {
+            readonly complete: "Completed";
+            readonly active: "In progress";
+            readonly pending: "Pending";
+            readonly attention: "Needs attention";
+            readonly blocked: "Blocked";
+            readonly skipped: "Skipped";
+        };
+    };
+    readonly datepicker: {
+        readonly placeholder: "Select a date...";
+        readonly rangePlaceholder: "Select a date range...";
+        readonly openCalendar: "Open calendar";
+        readonly invalidDate: "Invalid date";
+        readonly outOfRange: "Date is outside the allowed range";
+        readonly invalidRange: "Invalid date range";
+    };
+    readonly fileUpload: {
+        readonly exists: "File already added";
+        readonly invalidType: "File type {{type}} is not allowed";
+        readonly tooLarge: "File exceeds {{size}} limit";
+        readonly tooMany: "Maximum {{count}} files allowed";
+        readonly tooSmall: "File must be at least {{size}}";
+    };
+    readonly sankey: {
+        readonly summary: "Sankey diagram: {{nodes}} nodes, {{links}} links — {{flows}}";
+        readonly source: "Source";
+        readonly target: "Target";
+        readonly value: "Value";
+    };
+    readonly slider: {
+        readonly rangeStatus: {
+            readonly insideRecommended: "In recommended range";
+            readonly insideValid: "In valid range";
+            readonly insideValidOnly: "Outside recommended range, but valid";
+            readonly outsideValid: "Outside valid range";
+        };
+    };
+    readonly themeSwitcher: {
+        readonly lightMode: "Light mode";
+        readonly darkMode: "Dark mode";
+        readonly systemTheme: "System theme";
+    };
+    readonly chart: {
+        readonly category: "Category";
+        readonly series: "Series {{index}}";
+        readonly segment: "Segment";
+        readonly value: "Value";
+        readonly share: "Share";
+    };
+    readonly stepper: {
+        readonly optional: "Optional";
+    };
+}>;
 /**
  * Context-scoped translation hook for the blocks package. Call during component
  * initialisation, then use the returned `t` (conventionally aliased `bt`):
@@ -392,7 +580,195 @@ export declare const blocksI18n: import("@urbicon-ui/i18n").PackageI18n<import("
  * Resolves against the nearest `<I18nProvider>`'s locale (or the base locale
  * when none is mounted) and re-renders reactively on locale change.
  */
-export declare const useBlocksI18n: any;
+export declare const useBlocksI18n: () => import("@urbicon-ui/i18n").TypedTranslationFunction<{
+    readonly accessibility: {
+        readonly avatar: "Avatar";
+        readonly breadcrumb: "Breadcrumb";
+        readonly breadcrumbExpand: "Show all breadcrumb items";
+        readonly clearInput: "Clear input";
+        readonly clearSearch: "Clear search";
+        readonly clearSelection: "Clear selection";
+        readonly closeDialog: "Close dialog";
+        readonly closeDrawer: "Close drawer";
+        readonly dismiss: "Dismiss";
+        readonly fileUpload: "File upload";
+        readonly loading: "Loading";
+        readonly maximum: "Maximum";
+        readonly minimum: "Minimum";
+        readonly pagination: "Page navigation";
+        readonly progress: "Progress";
+        readonly slider: "Slider";
+        readonly toggle: "Toggle";
+        readonly toggleOptions: "Toggle options";
+        readonly removableBadge: "Removable badge";
+        readonly removeBadge: "Remove badge";
+        readonly removeFile: "Remove {{name}}";
+        readonly removeTag: "Remove {{label}}";
+    };
+    readonly button: {
+        readonly close: "Close";
+        readonly apply: "Apply";
+        readonly cancel: "Cancel";
+        readonly confirm: "Confirm";
+    };
+    readonly menu: {
+        readonly placeholder: "Select an option...";
+    };
+    readonly common: {
+        readonly loading: "Loading...";
+    };
+    readonly languages: {
+        readonly de: "Deutsch";
+        readonly en: "English";
+        readonly es: "Español";
+        readonly fr: "Français";
+        readonly it: "Italiano";
+        readonly nl: "Nederlands";
+    };
+    readonly localeSwitcher: {
+        readonly ariaLabel: "Language selection";
+        readonly placeholder: "Select language...";
+    };
+    readonly pagination: {
+        readonly next: "Next";
+        readonly first: "First";
+        readonly last: "Last";
+        readonly page: "Page";
+        readonly previous: "Previous";
+        readonly pageInfo: "{{label}} {{current}} of {{total}}";
+        readonly rangeInfo: "{{start}}–{{end}} of {{total}}";
+    };
+    readonly calendar: {
+        readonly recurring: "Recurring event";
+        readonly previousMonth: "Previous month";
+        readonly nextMonth: "Next month";
+        readonly previousWeek: "Previous week";
+        readonly nextWeek: "Next week";
+        readonly previousDay: "Previous day";
+        readonly nextDay: "Next day";
+        readonly previousYear: "Previous year";
+        readonly nextYear: "Next year";
+        readonly today: "Today";
+        readonly calendarGrid: "Calendar";
+        readonly weekdays: "Weekdays";
+        readonly weekNumber: "Week number";
+        readonly events: "Events";
+        readonly noEvents: "No events";
+        readonly showMore: "{{count}} more";
+        readonly legend: "Legend";
+        readonly yearView: "Year overview";
+        readonly weekView: "Week view";
+        readonly viewMonth: "Month";
+        readonly viewYear: "Year";
+        readonly viewWeek: "Week";
+        readonly viewDay: "Day";
+        readonly multiDayLabel: "Day {{current}} of {{total}}";
+        readonly agendaView: "Agenda view";
+        readonly viewAgenda: "Agenda";
+        readonly viewSwitcher: "View mode";
+    };
+    readonly planner: {
+        readonly previousWeek: "Previous week";
+        readonly nextWeek: "Next week";
+        readonly previousMonth: "Previous month";
+        readonly nextMonth: "Next month";
+        readonly previousRange: "Previous range";
+        readonly nextRange: "Next range";
+        readonly today: "Today";
+        readonly grid: "Planner";
+        readonly itemCount: "{{count}} items";
+    };
+    readonly commandPalette: {
+        readonly noResults: "No results found.";
+        readonly search: "Search...";
+        readonly hints: {
+            readonly navigate: "Navigate";
+            readonly select: "Select";
+            readonly close: "Close";
+        };
+    };
+    readonly compositionBar: {
+        readonly total: "Total";
+        readonly summary: "Composition: {{total}} ({{count}} shares) — {{parts}}";
+        readonly share: "Share";
+        readonly value: "Value";
+        readonly percent: "Percent";
+        readonly remaining: "remaining";
+    };
+    readonly guide: {
+        readonly next: "Next";
+        readonly previous: "Back";
+        readonly skip: "Skip tour";
+        readonly done: "Done";
+        readonly step: "Step {{current}} of {{total}}";
+        readonly tour: "Guided tour";
+        readonly close: "Close";
+        readonly openHelp: "Help";
+        readonly backToList: "All topics";
+        readonly info: "More information";
+        readonly infoAbout: "More information about {{label}}";
+        readonly dismiss: "Dismiss hint";
+        readonly startTour: "Start the guided tour";
+        readonly actionRequired: "Complete the highlighted action to continue";
+        readonly filterPlaceholder: "Filter topics…";
+        readonly noResults: "No matching topics";
+    };
+    readonly journeyTimeline: {
+        readonly label: "Journey";
+        readonly status: {
+            readonly complete: "Completed";
+            readonly active: "In progress";
+            readonly pending: "Pending";
+            readonly attention: "Needs attention";
+            readonly blocked: "Blocked";
+            readonly skipped: "Skipped";
+        };
+    };
+    readonly datepicker: {
+        readonly placeholder: "Select a date...";
+        readonly rangePlaceholder: "Select a date range...";
+        readonly openCalendar: "Open calendar";
+        readonly invalidDate: "Invalid date";
+        readonly outOfRange: "Date is outside the allowed range";
+        readonly invalidRange: "Invalid date range";
+    };
+    readonly fileUpload: {
+        readonly exists: "File already added";
+        readonly invalidType: "File type {{type}} is not allowed";
+        readonly tooLarge: "File exceeds {{size}} limit";
+        readonly tooMany: "Maximum {{count}} files allowed";
+        readonly tooSmall: "File must be at least {{size}}";
+    };
+    readonly sankey: {
+        readonly summary: "Sankey diagram: {{nodes}} nodes, {{links}} links — {{flows}}";
+        readonly source: "Source";
+        readonly target: "Target";
+        readonly value: "Value";
+    };
+    readonly slider: {
+        readonly rangeStatus: {
+            readonly insideRecommended: "In recommended range";
+            readonly insideValid: "In valid range";
+            readonly insideValidOnly: "Outside recommended range, but valid";
+            readonly outsideValid: "Outside valid range";
+        };
+    };
+    readonly themeSwitcher: {
+        readonly lightMode: "Light mode";
+        readonly darkMode: "Dark mode";
+        readonly systemTheme: "System theme";
+    };
+    readonly chart: {
+        readonly category: "Category";
+        readonly series: "Series {{index}}";
+        readonly segment: "Segment";
+        readonly value: "Value";
+        readonly share: "Share";
+    };
+    readonly stepper: {
+        readonly optional: "Optional";
+    };
+}>;
 export declare const hasBlocksTranslation: (key: string) => boolean, getBlocksLocales: () => import("@urbicon-ui/i18n").Locale[];
 export type BlocksTranslationKey = keyof typeof enTranslations;
 export { blocksTranslations };

package/dist/mint/README.md

@@ -162,6 +162,39 @@ mintRegistry.register('my-mint', (config) => ({
 - **Throttling**: Verhindert Spam bei schnellen Interaktionen
 - **Cleanup**: Automatische Bereinigung bei Component-Unmount
 
+## Auflösung & Tree-Shaking (resolveIcon-Muster)
+
+`mintRegistry.apply(el, mint, fallbacks?)` löst jeden Mint-Namen in dieser
+Reihenfolge auf:
+
+1. **Registry-Eintrag** — Consumer-`register()`-Override oder bereits geladene
+   Built-ins (gewinnt immer, wie der IconProvider bei `resolveIcon`).
+2. **`fallbacks`** — statisch importierte Factories des Aufrufers. Button
+   importiert `scaleMint` direkt (`{ scale: scaleMint }`), damit sein Default
+   tree-shaken mitkommt, ohne das gesamte Built-in-Set zu ziehen.
+3. **Demand-Load** — unbekannte Namen laden das Built-in-Set einmalig per
+   dynamischem `import('./presets')` nach (Chunk wird nur gefetcht, wenn
+   tatsächlich ein dynamischer Mint-Name verwendet wird) und wenden den Effekt
+   danach an. `<Button mint="ripple">` funktioniert also weiterhin ohne
+   manuelles `registerDefaultMints()`.
+
+**Kontrakt Demand-Load (dokumentiert):** Mint-Effekte sind dekorativ.
+Interaktionen im Fetch-Fenster werden NICHT nachgespielt — auf langsamen
+Netzen kann der erste Klick für einen noch nicht geladenen click-getriggerten
+Effekt (`ripple`, `shake`, …) verloren gehen; hover-getriggerte Effekte
+greifen ab dem nächsten `mouseenter`. Consumer-Overrides überleben den
+Demand-Load immer (die Built-ins registrieren sich nur auf freie Namen —
+`registerBuiltin`). Wer First-Interaction-Garantien braucht, registriert den
+Effekt statisch beim App-Start: `registerDefaultMints()` oder
+`mintRegistry.register(name, factory)` mit direkt importierter Factory.
+
+Modul-Layout (load-bearing für die Chunk-Zuordnung): `engine.ts` enthält die
+Micro-Interaction-Engine + `scaleMint` (schifft statisch mit Button);
+`micro-interactions.ts` enthält NUR die Registrierungen und ist ausschließlich
+über den demand-geladenen `presets.ts`-Chunk erreichbar. Neue statisch
+verschiffte Default-Effekte gehören in `engine.ts` (oder ein eigenes Modul),
+niemals in `micro-interactions.ts`.
+
 ## Accessibility
 
 Das Mint-System respektiert automatisch `prefers-reduced-motion`:

package/dist/mint/compose.d.ts

@@ -1,7 +1,13 @@
 import { mintRegistry } from './registry.js';
 import type { CompositeConfig, Mint } from './types.js';
 /**
- * Compose multiple mints into one
+ * Compose multiple mints into one.
+ *
+ * String members resolve like `mintRegistry.apply` does: a registry entry
+ * (consumer override or loaded built-in) applies synchronously; unresolved
+ * names demand-load the built-in set once and init after the load (skipped if
+ * the composite was destroyed in the meantime). A name that is still unknown
+ * after the load warns loudly instead of silently dropping the effect.
  */
 export declare function composeMints(...mints: Array<Mint | string>): Mint;
 /**

package/dist/mint/compose.js

@@ -1,26 +1,53 @@
-import { mintRegistry } from './registry.js';
+import { loadBuiltinMints, mintRegistry } from './registry.js';
 /**
- * Compose multiple mints into one
+ * Compose multiple mints into one.
+ *
+ * String members resolve like `mintRegistry.apply` does: a registry entry
+ * (consumer override or loaded built-in) applies synchronously; unresolved
+ * names demand-load the built-in set once and init after the load (skipped if
+ * the composite was destroyed in the meantime). A name that is still unknown
+ * after the load warns loudly instead of silently dropping the effect.
  */
 export function composeMints(...mints) {
     return {
         init(el, config) {
             const instances = [];
+            let disposed = false;
+            const applyInstance = (instance) => {
+                instance.init(el, config);
+                instances.push(instance);
+            };
+            const unresolved = [];
             mints.forEach((mint) => {
                 if (typeof mint === 'string') {
                     const factory = mintRegistry.get(mint);
                     if (factory) {
-                        const instance = factory(config);
-                        instance.init(el, config);
-                        instances.push(instance);
+                        applyInstance(factory(config));
+                    }
+                    else {
+                        unresolved.push(mint);
                     }
                 }
                 else {
-                    mint.init(el, config);
-                    instances.push(mint);
+                    applyInstance(mint);
                 }
             });
+            if (unresolved.length > 0) {
+                void loadBuiltinMints().then(() => {
+                    if (disposed)
+                        return;
+                    unresolved.forEach((name) => {
+                        const factory = mintRegistry.get(name);
+                        if (!factory) {
+                            console.warn(`[composeMints] Unknown mint: ${name}`);
+                            return;
+                        }
+                        applyInstance(factory(config));
+                    });
+                });
+            }
             this.destroy = () => {
+                disposed = true;
                 instances.forEach((instance) => {
                     instance.destroy?.(el);
                 });
@@ -46,5 +73,5 @@ export function createCompositeMint() {
  * Called by registerDefaultMints() - not at module level.
  */
 export function registerComposite(registry) {
-    registry.register('composite', createCompositeMint);
+    registry.registerBuiltin('composite', createCompositeMint);
 }

package/dist/mint/engine.d.ts

@@ -0,0 +1,34 @@
+import type { MicroInteractionConfig, Mint, MintFactory } from './types.js';
+/**
+ * Micro-interaction engine + the statically-shipped default effect (scale).
+ *
+ * This module split is load-bearing for tree-shaking: everything in this file
+ * ships statically with components that import `scaleMint` (Button's mint
+ * default), while the per-effect registrations stay in
+ * `./micro-interactions.ts`, which is only reachable through the
+ * demand-loaded `./presets.ts` chunk. Rollup assigns a shared module's whole
+ * used-export-set to the chunk that statically owns it — if the registrations
+ * lived in this file, `registerMicroInteractions` (used by the lazy presets
+ * chunk) would be pulled into every Button consumer's initial bundle again.
+ * Add future statically-defaulted effects here (or in their own module),
+ * never in `micro-interactions.ts`.
+ */
+/**
+ * Check if user prefers reduced motion
+ * @internal Shared with ./micro-interactions.ts; not part of the public API.
+ */
+export declare function prefersReducedMotion(): boolean;
+/**
+ * Generic micro-interaction factory
+ */
+export declare function createMicroInteraction(className: string, defaultConfig?: MicroInteractionConfig): Mint<MicroInteractionConfig>;
+/**
+ * The `scale` micro-interaction factory, exported standalone so components
+ * whose mint *default* is `'scale'` (Button) can import it directly and pass
+ * it as a fallback: `mintRegistry.apply(el, mint, { scale: scaleMint })`.
+ * That is the `resolveIcon` tree-shaking pattern — the default effect ships
+ * with the component; the rest of the built-in set stays demand-loaded.
+ * `registerDefaultMints()` registers this same factory, so the registry path
+ * and the fallback path are behaviour-identical.
+ */
+export declare const scaleMint: MintFactory<MicroInteractionConfig>;

package/dist/mint/engine.js

@@ -0,0 +1,106 @@
+/**
+ * Micro-interaction engine + the statically-shipped default effect (scale).
+ *
+ * This module split is load-bearing for tree-shaking: everything in this file
+ * ships statically with components that import `scaleMint` (Button's mint
+ * default), while the per-effect registrations stay in
+ * `./micro-interactions.ts`, which is only reachable through the
+ * demand-loaded `./presets.ts` chunk. Rollup assigns a shared module's whole
+ * used-export-set to the chunk that statically owns it — if the registrations
+ * lived in this file, `registerMicroInteractions` (used by the lazy presets
+ * chunk) would be pulled into every Button consumer's initial bundle again.
+ * Add future statically-defaulted effects here (or in their own module),
+ * never in `micro-interactions.ts`.
+ */
+/**
+ * Check if user prefers reduced motion
+ * @internal Shared with ./micro-interactions.ts; not part of the public API.
+ */
+export function prefersReducedMotion() {
+    return window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+}
+/**
+ * Generic micro-interaction factory
+ */
+export function createMicroInteraction(className, defaultConfig = {}) {
+    return {
+        init(el, config = {}) {
+            // Merge default config with provided config
+            const finalConfig = { ...defaultConfig, ...config };
+            // Skip if disabled or prefers reduced motion
+            if (finalConfig.disabled || prefersReducedMotion())
+                return;
+            const trigger = finalConfig.trigger || 'hover';
+            const duration = finalConfig.duration || 200;
+            const delay = finalConfig.delay || 0;
+            // Determine event based on trigger
+            const eventMap = {
+                hover: 'mouseenter',
+                click: 'click',
+                focus: 'focus',
+                load: 'load'
+            };
+            const event = eventMap[trigger] || 'mouseenter';
+            const handler = () => {
+                // Skip if this specific animation is already running
+                const animatingAttr = `data-animating-${className}`;
+                if (el.getAttribute(animatingAttr) === 'true')
+                    return;
+                // Apply delay if specified
+                const applyAnimation = () => {
+                    el.setAttribute(animatingAttr, 'true');
+                    // Add dynamic styles if intensity is specified
+                    if (finalConfig.intensity && className.includes('scale')) {
+                        el.style.setProperty('--scale-intensity', finalConfig.intensity.toString());
+                    }
+                    el.classList.add(className);
+                    const cleanup = () => {
+                        el.classList.remove(className);
+                        el.removeAttribute(animatingAttr);
+                        el.style.removeProperty('--scale-intensity');
+                        el.removeEventListener('animationend', cleanup);
+                        el.removeEventListener('transitionend', cleanup);
+                    };
+                    el.addEventListener('animationend', cleanup, { once: true });
+                    el.addEventListener('transitionend', cleanup, { once: true });
+                    // Fallback timeout
+                    setTimeout(cleanup, duration + 50);
+                };
+                if (delay > 0) {
+                    setTimeout(applyAnimation, delay);
+                }
+                else {
+                    applyAnimation();
+                }
+            };
+            // Special handling for load trigger
+            if (trigger === 'load') {
+                // Execute immediately if element is already loaded
+                requestAnimationFrame(() => handler());
+            }
+            else {
+                el.addEventListener(event, handler, { passive: true });
+            }
+            // Store cleanup function
+            this.destroy = () => {
+                if (event !== 'load') {
+                    el.removeEventListener(event, handler);
+                }
+            };
+        }
+    };
+}
+/**
+ * The `scale` micro-interaction factory, exported standalone so components
+ * whose mint *default* is `'scale'` (Button) can import it directly and pass
+ * it as a fallback: `mintRegistry.apply(el, mint, { scale: scaleMint })`.
+ * That is the `resolveIcon` tree-shaking pattern — the default effect ships
+ * with the component; the rest of the built-in set stays demand-loaded.
+ * `registerDefaultMints()` registers this same factory, so the registry path
+ * and the fallback path are behaviour-identical.
+ */
+export const scaleMint = (config) => createMicroInteraction('blocks-mint-scale', {
+    trigger: 'hover',
+    duration: 200,
+    ...config
+});

package/dist/mint/index.d.ts

@@ -1,7 +1,7 @@
 export { composeMints, createCompositeMint } from './compose.js';
-export { createMicroInteraction } from './micro-interactions.js';
+export { createMicroInteraction, scaleMint } from './engine.js';
 export { mintPresets, registerBusinessMints, registerDefaultMints, registerPlayfulMints } from './presets.js';
-export { mintRegistry } from './registry.js';
+export { type MintFallbacks, mintRegistry } from './registry.js';
 export { createRippleMint } from './ripple.js';
 export { mint, useMint } from './svelte.js';
 export * from './types.js';

package/dist/mint/index.js

@@ -1,7 +1,7 @@
 // Core exports
 export { composeMints, createCompositeMint } from './compose.js';
 // Mint factories
-export { createMicroInteraction } from './micro-interactions.js';
+export { createMicroInteraction, scaleMint } from './engine.js';
 // Presets
 export { mintPresets, registerBusinessMints, registerDefaultMints, registerPlayfulMints } from './presets.js';
 export { mintRegistry } from './registry.js';