@blueprint-platform/components 0.0.0-stage → 0.2.0

package/dist/generators/ui/files/shared/ui/utils/src/lib/hlm.ts

@@ -0,0 +1,313 @@
+import { isPlatformBrowser } from '@angular/common';
+import {
+  DestroyRef,
+  effect,
+  ElementRef,
+  HostAttributeToken,
+  inject,
+  Injector,
+  PLATFORM_ID,
+  runInInjectionContext,
+} from '@angular/core';
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function hlm(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+// Global map to track class managers per element
+const elementClassManagers = new WeakMap<HTMLElement, ElementClassManager>();
+// Global mutation observer for all elements
+let globalObserver: MutationObserver | null = null;
+const observedElements = new Set<HTMLElement>();
+
+interface ElementClassManager {
+  element: HTMLElement;
+  sources: Map<number, { classes: Set<string>; order: number }>;
+  baseClasses: Set<string>;
+  isUpdating: boolean;
+  nextOrder: number;
+  hasInitialized: boolean;
+  restoreRafId: number | null;
+  /** Transitions are suppressed until the first effect writes correct classes */
+  transitionsSuppressed: boolean;
+  /** Original inline transition value to restore after suppression (empty string = none was set) */
+  previousTransition: string;
+  /** Original inline transition priority to preserve !important when restoring */
+  previousTransitionPriority: string;
+}
+
+let sourceCounter = 0;
+
+/**
+ * This function dynamically adds and removes classes for a given element without requiring
+ * the a class binding (e.g. `[class]="..."`) which may interfere with other class bindings.
+ *
+ * 1. This will merge the existing classes on the element with the new classes.
+ * 2. It will also remove any classes that were previously added by this function but are no longer present in the new classes.
+ * 3. Multiple calls to this function on the same element will be merged efficiently.
+ */
+export function classes(computed: () => ClassValue[] | string, options: ClassesOptions = {}) {
+  runInInjectionContext(options.injector ?? inject(Injector), () => {
+    const elementRef = options.elementRef ?? inject(ElementRef);
+    const platformId = inject(PLATFORM_ID);
+    const destroyRef = inject(DestroyRef);
+    const baseClasses = inject(new HostAttributeToken('class'), { optional: true });
+
+    const element = elementRef.nativeElement;
+
+    // Create unique identifier for this source
+    const sourceId = sourceCounter++;
+
+    // Get or create the class manager for this element
+    let manager = elementClassManagers.get(element);
+
+    if (!manager) {
+      // Initialize base classes from variation (host attribute 'class')
+      const initialBaseClasses = new Set<string>();
+
+      if (baseClasses) {
+        toClassList(baseClasses).forEach((cls) => initialBaseClasses.add(cls));
+      }
+
+      manager = {
+        element,
+        sources: new Map(),
+        baseClasses: initialBaseClasses,
+        isUpdating: false,
+        nextOrder: 0,
+        hasInitialized: false,
+        restoreRafId: null,
+        transitionsSuppressed: false,
+        previousTransition: '',
+        previousTransitionPriority: '',
+      };
+      elementClassManagers.set(element, manager);
+
+      // Setup global observer if needed and register this element
+      setupGlobalObserver(platformId);
+      observedElements.add(element);
+
+      // Suppress transitions until the first effect writes correct classes and
+      // the browser has painted them. This prevents CSS transition animations
+      // during hydration when classes change from SSR state to client state.
+      if (isPlatformBrowser(platformId)) {
+        manager.previousTransition = element.style.getPropertyValue('transition');
+        manager.previousTransitionPriority = element.style.getPropertyPriority('transition');
+        element.style.setProperty('transition', 'none', 'important');
+        manager.transitionsSuppressed = true;
+      }
+    }
+
+    // Assign order once at registration time
+    const sourceOrder = manager.nextOrder++;
+
+    function updateClasses(): void {
+      // Get the new classes from the computed function
+      const newClasses = toClassList(computed());
+
+      // Update this source's classes, keeping the original order
+      manager!.sources.set(sourceId, {
+        classes: new Set(newClasses),
+        order: sourceOrder,
+      });
+
+      // Update the element
+      updateElement(manager!);
+
+      // Re-enable transitions after the first effect writes correct classes.
+      // Deferred to next animation frame so the browser paints the class change
+      // with transitions disabled first, then re-enables them.
+      if (manager!.transitionsSuppressed) {
+        manager!.transitionsSuppressed = false;
+        manager!.restoreRafId = requestAnimationFrame(() => {
+          manager!.restoreRafId = null;
+          restoreTransitionSuppression(manager!);
+        });
+      }
+    }
+
+    // Register cleanup with DestroyRef
+    destroyRef.onDestroy(() => {
+      if (manager!.restoreRafId !== null) {
+        cancelAnimationFrame(manager!.restoreRafId);
+        manager!.restoreRafId = null;
+      }
+
+      if (manager!.transitionsSuppressed) {
+        manager!.transitionsSuppressed = false;
+        restoreTransitionSuppression(manager!);
+      }
+
+      // Remove this source from the manager
+      manager!.sources.delete(sourceId);
+
+      // If no more sources, clean up the manager
+      if (manager!.sources.size === 0) {
+        cleanupManager(element);
+      } else {
+        // Update element without this source's classes
+        updateElement(manager!);
+      }
+    });
+
+    /**
+     * We need this effect to track changes to the computed classes. Ideally, we would use
+     * afterRenderEffect here, but that doesn't run in SSR contexts, so we use a standard
+     * effect which works in both browser and SSR.
+     */
+    effect(updateClasses);
+  });
+}
+
+function restoreTransitionSuppression(manager: ElementClassManager): void {
+  const prev = manager.previousTransition;
+  if (prev) {
+    manager.element.style.setProperty(
+      'transition',
+      prev,
+      manager.previousTransitionPriority || undefined,
+    );
+  } else {
+    manager.element.style.removeProperty('transition');
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
+function setupGlobalObserver(platformId: Object): void {
+  if (isPlatformBrowser(platformId) && !globalObserver) {
+    // Create single global observer that watches the entire document
+    globalObserver = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
+          const element = mutation.target as HTMLElement;
+          const manager = elementClassManagers.get(element);
+
+          // Only process elements we're managing
+          if (manager && observedElements.has(element)) {
+            if (manager.isUpdating) continue; // Ignore changes we're making
+
+            // Update base classes to include any externally added classes
+            const currentClasses = toClassList(element.className);
+            const allSourceClasses = new Set<string>();
+
+            // Collect all classes from all sources
+            for (const source of manager.sources.values()) {
+              for (const className of source.classes) {
+                allSourceClasses.add(className);
+              }
+            }
+
+            // Any classes not from sources become new base classes
+            manager.baseClasses.clear();
+
+            for (const className of currentClasses) {
+              if (!allSourceClasses.has(className)) {
+                manager.baseClasses.add(className);
+              }
+            }
+
+            updateElement(manager);
+          }
+        }
+      }
+    });
+
+    // Start observing the entire document for class attribute changes
+    globalObserver.observe(document, {
+      attributes: true,
+      attributeFilter: ['class'],
+      subtree: true, // Watch all descendants
+    });
+  }
+}
+
+function updateElement(manager: ElementClassManager): void {
+  if (manager.isUpdating) return; // Prevent recursive updates
+
+  manager.isUpdating = true;
+
+  // Handle initialization: capture base classes after first source registration
+  if (!manager.hasInitialized && manager.sources.size > 0) {
+    // Get current classes on element (may include SSR classes)
+    const currentClasses = toClassList(manager.element.className);
+
+    // Get all classes that will be applied by sources
+    const allSourceClasses = new Set<string>();
+    for (const source of manager.sources.values()) {
+      source.classes.forEach((className) => allSourceClasses.add(className));
+    }
+
+    // Only consider classes as "base" if they're not produced by any source
+    // This prevents SSR-rendered classes from being preserved as base classes
+    currentClasses.forEach((className) => {
+      if (!allSourceClasses.has(className)) {
+        manager.baseClasses.add(className);
+      }
+    });
+
+    manager.hasInitialized = true;
+  }
+
+  // Get classes from all sources, sorted by registration order (later takes precedence)
+  const sortedSources = Array.from(manager.sources.entries()).sort(
+    ([, a], [, b]) => a.order - b.order,
+  );
+
+  const allSourceClasses: string[] = [];
+  for (const [, source] of sortedSources) {
+    allSourceClasses.push(...source.classes);
+  }
+
+  // Combine base classes with all source classes, ensuring base classes take precedence
+  const classesToApply =
+    allSourceClasses.length > 0 || manager.baseClasses.size > 0
+      ? hlm([...allSourceClasses, ...manager.baseClasses])
+      : '';
+
+  // Apply the classes to the element
+  if (manager.element.className !== classesToApply) {
+    manager.element.className = classesToApply;
+  }
+
+  manager.isUpdating = false;
+}
+
+function cleanupManager(element: HTMLElement): void {
+  // Remove from global tracking
+  observedElements.delete(element);
+  elementClassManagers.delete(element);
+
+  // If no more elements being tracked, cleanup global observer
+  if (observedElements.size === 0 && globalObserver) {
+    globalObserver.disconnect();
+    globalObserver = null;
+  }
+}
+
+interface ClassesOptions {
+  elementRef?: ElementRef<HTMLElement>;
+  injector?: Injector;
+}
+
+// Cache for parsed class lists to avoid repeated string operations
+const classListCache = new Map<string, string[]>();
+
+function toClassList(className: string | ClassValue[]): string[] {
+  // For simple string inputs, use cache to avoid repeated parsing
+  if (typeof className === 'string' && classListCache.has(className)) {
+    return classListCache.get(className)!;
+  }
+
+  const result = clsx(className)
+    .split(' ')
+    .filter((c) => c.length > 0);
+
+  // Cache string results, but limit cache size to prevent memory growth
+  if (typeof className === 'string' && classListCache.size < 1000) {
+    classListCache.set(className, result);
+  }
+
+  return result;
+}

package/dist/generators/ui/files/shared/ui/utils/src/lib/provide-spartan-hlm.ts

@@ -0,0 +1,34 @@
+import { OVERLAY_DEFAULT_CONFIG } from '@angular/cdk/overlay';
+import { type EnvironmentProviders, makeEnvironmentProviders } from '@angular/core';
+
+/**
+ * Provides default configuration for Spartan Helm components.
+ *
+ * This utility configures the Angular CDK overlay to disable the `usePopover`
+ * behavior introduced in Angular 21, which causes CDK overlay-based components
+ * (sheets, dialogs, tooltips, etc.) to render above `position: fixed` elements
+ * like `<hlm-toaster>`.
+ *
+ * @returns {EnvironmentProviders} Environment providers to be added to the application config.
+ *
+ * @example
+ * ```ts
+ * // app.config.ts
+ * import { provideSpartanHlm } from '@spartan-ng/helm/utils';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideSpartanHlm(),
+ *     // ... other providers
+ *   ],
+ * };
+ * ```
+ */
+export function provideSpartanHlm(): EnvironmentProviders {
+  return makeEnvironmentProviders([
+    {
+      provide: OVERLAY_DEFAULT_CONFIG,
+      useValue: { usePopover: false },
+    },
+  ]);
+}

package/dist/generators/ui/lib/npm-deps.d.ts

@@ -0,0 +1,14 @@
+/**
+ * npm packages a synced UI component may import, mapped to the range the
+ * generated project should pin. `@spartan-ng/brain` covers every `@spartan-ng/brain/*`
+ * subpath (one package, many entry points). `@angular/*`, `clsx` type-only, `rxjs`
+ * etc. are provided by the Angular app itself and are intentionally absent.
+ */
+export declare const UI_NPM_DEPS: Record<string, string>;
+/**
+ * Scan the given components' source for third-party imports and return the
+ * `{ package: range }` map the generated project needs. Only real `from '...'`
+ * specifiers count — doc-comment mentions do not.
+ */
+export declare function npmDepsForComponents(names: string[]): Record<string, string>;
+//# sourceMappingURL=npm-deps.d.ts.map

package/dist/generators/ui/lib/npm-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"npm-deps.d.ts","sourceRoot":"","sources":["file:///d:/blueprint-platform/packages/components/src/generators/ui/lib/npm-deps.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAU9C,CAAC;AA2BF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgB5E"}

package/dist/generators/ui/lib/npm-deps.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UI_NPM_DEPS = void 0;
+exports.npmDepsForComponents = npmDepsForComponents;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const resolve_deps_1 = require("./resolve-deps");
+/**
+ * npm packages a synced UI component may import, mapped to the range the
+ * generated project should pin. `@spartan-ng/brain` covers every `@spartan-ng/brain/*`
+ * subpath (one package, many entry points). `@angular/*`, `clsx` type-only, `rxjs`
+ * etc. are provided by the Angular app itself and are intentionally absent.
+ */
+exports.UI_NPM_DEPS = {
+    '@spartan-ng/brain': '^1.0.0',
+    '@ng-icons/core': '^32.0.0',
+    '@ng-icons/lucide': '^32.0.0',
+    'class-variance-authority': '^0.7.0',
+    clsx: '^2.1.0',
+    'tailwind-merge': '^2.5.0',
+    'embla-carousel': '^8.0.0',
+    'embla-carousel-angular': '^22.0.0',
+    'ngx-scrollbar': '^19.1.0',
+};
+/** Bare module specifiers matched against `from '<spec>'` in a component's source. */
+const SPECIFIER_TO_PKG = [
+    { test: /^@spartan-ng\/brain(\/|$)/, pkg: '@spartan-ng/brain' },
+    { test: /^@ng-icons\/core(\/|$)/, pkg: '@ng-icons/core' },
+    { test: /^@ng-icons\/lucide(\/|$)/, pkg: '@ng-icons/lucide' },
+    { test: /^class-variance-authority(\/|$)/, pkg: 'class-variance-authority' },
+    { test: /^clsx(\/|$)/, pkg: 'clsx' },
+    { test: /^tailwind-merge(\/|$)/, pkg: 'tailwind-merge' },
+    { test: /^embla-carousel-angular(\/|$)/, pkg: 'embla-carousel-angular' },
+    { test: /^embla-carousel(\/|$)/, pkg: 'embla-carousel' },
+    { test: /^ngx-scrollbar(\/|$)/, pkg: 'ngx-scrollbar' },
+];
+const IMPORT_RE = /(?:import|export)[^'"]*?from\s*['"]([^'"]+)['"]/g;
+function tsFilesOf(dir) {
+    const out = [];
+    for (const entry of (0, fs_1.readdirSync)(dir)) {
+        const full = (0, path_1.join)(dir, entry);
+        if ((0, fs_1.statSync)(full).isDirectory())
+            out.push(...tsFilesOf(full));
+        else if (entry.endsWith('.ts'))
+            out.push(full);
+    }
+    return out;
+}
+/**
+ * Scan the given components' source for third-party imports and return the
+ * `{ package: range }` map the generated project needs. Only real `from '...'`
+ * specifiers count — doc-comment mentions do not.
+ */
+function npmDepsForComponents(names) {
+    const found = new Set();
+    for (const name of names) {
+        for (const file of tsFilesOf((0, path_1.join)(resolve_deps_1.UI_FILES_DIR, name))) {
+            const src = (0, fs_1.readFileSync)(file, 'utf-8');
+            let m;
+            while ((m = IMPORT_RE.exec(src)) !== null) {
+                const spec = m[1];
+                const hit = SPECIFIER_TO_PKG.find((s) => s.test.test(spec));
+                if (hit)
+                    found.add(hit.pkg);
+            }
+        }
+    }
+    const result = {};
+    for (const pkg of found)
+        result[pkg] = exports.UI_NPM_DEPS[pkg];
+    return result;
+}

package/dist/generators/ui/lib/resolve-deps.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The bundled component sources. At runtime this file is
+ * `dist/generators/ui/lib/resolve-deps.js`, so the payload sits one level up.
+ */
+export declare const UI_FILES_DIR: string;
+/**
+ * Components with no `src/index.ts` barrel — copied as a single flat file and
+ * consumed via relative imports, so they never get a `@blueprint-platform/ui/<name>`
+ * tsconfig path.
+ */
+export declare const FLAT_COMPONENTS: string[];
+/** Every component folder that ships with the package. */
+export declare function listAllComponents(): string[];
+export declare function componentExists(name: string): boolean;
+/** Direct in-kit dependencies of one component. */
+export declare function directDeps(name: string): string[];
+/**
+ * Breadth-first transitive closure of the requested components over their
+ * in-kit dependencies. Unknown names are returned in `missing`.
+ */
+export declare function resolveClosure(requested: string[]): {
+    closure: string[];
+    missing: string[];
+};
+//# sourceMappingURL=resolve-deps.d.ts.map

package/dist/generators/ui/lib/resolve-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-deps.d.ts","sourceRoot":"","sources":["file:///d:/blueprint-platform/packages/components/src/generators/ui/lib/resolve-deps.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,YAAY,QAAiD,CAAC;AAE3E;;;;GAIG;AACH,eAAO,MAAM,eAAe,UAAuD,CAAC;AAEpF,0DAA0D;AAC1D,wBAAgB,iBAAiB,IAAI,MAAM,EAAE,CAI5C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAYD,mDAAmD;AACnD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAcjD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG;IACnD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAWA"}

package/dist/generators/ui/lib/resolve-deps.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLAT_COMPONENTS = exports.UI_FILES_DIR = void 0;
+exports.listAllComponents = listAllComponents;
+exports.componentExists = componentExists;
+exports.directDeps = directDeps;
+exports.resolveClosure = resolveClosure;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * The bundled component sources. At runtime this file is
+ * `dist/generators/ui/lib/resolve-deps.js`, so the payload sits one level up.
+ */
+exports.UI_FILES_DIR = (0, path_1.join)(__dirname, '..', 'files', 'shared', 'ui');
+/**
+ * Components with no `src/index.ts` barrel — copied as a single flat file and
+ * consumed via relative imports, so they never get a `@blueprint-platform/ui/<name>`
+ * tsconfig path.
+ */
+exports.FLAT_COMPONENTS = ['user-menu', 'theme-switcher', 'language-switcher'];
+/** Every component folder that ships with the package. */
+function listAllComponents() {
+    return (0, fs_1.readdirSync)(exports.UI_FILES_DIR).filter((name) => (0, fs_1.statSync)((0, path_1.join)(exports.UI_FILES_DIR, name)).isDirectory());
+}
+function componentExists(name) {
+    return (0, fs_1.existsSync)((0, path_1.join)(exports.UI_FILES_DIR, name));
+}
+function tsFilesOf(dir) {
+    const out = [];
+    for (const entry of (0, fs_1.readdirSync)(dir)) {
+        const full = (0, path_1.join)(dir, entry);
+        if ((0, fs_1.statSync)(full).isDirectory())
+            out.push(...tsFilesOf(full));
+        else if (entry.endsWith('.ts'))
+            out.push(full);
+    }
+    return out;
+}
+/** Direct in-kit dependencies of one component. */
+function directDeps(name) {
+    const deps = new Set();
+    for (const file of tsFilesOf((0, path_1.join)(exports.UI_FILES_DIR, name))) {
+        const src = (0, fs_1.readFileSync)(file, 'utf-8');
+        // `@blueprint-platform/ui/<dep>` — the aliased barrel imports.
+        for (const m of src.matchAll(/@blueprint-platform\/ui\/([a-z0-9-]+)/g)) {
+            if (m[1] !== name)
+                deps.add(m[1]);
+        }
+        // Flat-family siblings imported relatively, e.g. `from '../theme-switcher/theme-switcher'`.
+        for (const m of src.matchAll(/from\s+['"]\.\.\/([a-z0-9-]+)\/[^'"]+['"]/g)) {
+            if (m[1] !== name && componentExists(m[1]))
+                deps.add(m[1]);
+        }
+    }
+    return [...deps];
+}
+/**
+ * Breadth-first transitive closure of the requested components over their
+ * in-kit dependencies. Unknown names are returned in `missing`.
+ */
+function resolveClosure(requested) {
+    const missing = requested.filter((n) => !componentExists(n));
+    const seen = new Set();
+    const queue = requested.filter((n) => componentExists(n));
+    while (queue.length) {
+        const name = queue.shift();
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        for (const dep of directDeps(name))
+            if (!seen.has(dep))
+                queue.push(dep);
+    }
+    return { closure: [...seen], missing };
+}

package/dist/generators/ui/schema.d.ts

@@ -0,0 +1,14 @@
+export interface UiGeneratorSchema {
+  /** Component name(s) — comma or space separated. Ignored when `all` is true. */
+  components?: string;
+  /** Add every available UI component not already in the project. */
+  all?: boolean;
+  /** Print every available component name and exit without writing anything. */
+  list?: boolean;
+  /** Project root to add components into. */
+  project?: string;
+  /** Skip Prettier. */
+  skipFormat?: boolean;
+  /** Skip installing newly added npm dependencies. */
+  skipInstall?: boolean;
+}

package/dist/generators/ui/schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "BlueprintComponentsUi",
+  "title": "Add Blueprint UI components",
+  "description": "Copy one or more spartan-derived UI components (and their dependencies) into an existing Blueprint project.",
+  "type": "object",
+  "properties": {
+    "components": {
+      "type": "string",
+      "description": "Component name(s) to add — comma or space separated (e.g. \"carousel,accordion\").",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "Which UI component(s) do you want to add?"
+    },
+    "all": {
+      "type": "boolean",
+      "description": "Add every available UI component not already present in the project.",
+      "default": false
+    },
+    "list": {
+      "type": "boolean",
+      "description": "Print every available UI component name and exit without writing anything.",
+      "default": false
+    },
+    "project": {
+      "type": "string",
+      "description": "Path to the project root to add components into.",
+      "default": "."
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip running Prettier on the touched files.",
+      "default": false
+    },
+    "skipInstall": {
+      "type": "boolean",
+      "description": "Skip installing newly added npm dependencies.",
+      "default": false
+    }
+  },
+  "required": []
+}

package/dist/generators/ui/ui.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import { UiGeneratorSchema } from './schema';
+export default function uiGenerator(tree: Tree, options: UiGeneratorSchema): Promise<(() => void) | undefined>;
+//# sourceMappingURL=ui.d.ts.map

package/dist/generators/ui/ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.d.ts","sourceRoot":"","sources":["file:///d:/blueprint-platform/packages/components/src/generators/ui/ui.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAOL,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAgB7C,wBAA8B,WAAW,CACvC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,iBAAiB,qCA6F3B"}