zuljaman-banner-components 1.0.23 → 1.0.24

package/dist/components/BannerRenderer/utils/alignmentUtils.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Alignment utility functions for BannerRenderer
+ * Pure functions for calculating alignment guides between elements
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAlignmentLinesBetween = calculateAlignmentLinesBetween;
+exports.calculateAllAlignmentLines = calculateAllAlignmentLines;
+/**
+ * Calculate alignment lines between a dragged element and another element.
+ * Uses relative bounds (relative to container center).
+ *
+ * @param dragged - Relative bounds of the dragged element
+ * @param other - Relative bounds of the other element
+ * @param tolerance - Alignment tolerance in pixels (default: 0.5)
+ * @returns Array of alignment lines
+ */
+function calculateAlignmentLinesBetween(dragged, other, tolerance = 0.5) {
+    const alignments = [];
+    // Vertical lines (horizontal alignment)
+    // Left alignment
+    if (Math.abs(dragged.left - other.left) < tolerance) {
+        alignments.push({
+            x: dragged.left,
+            y1: Math.min(dragged.top, other.top),
+            y2: Math.max(dragged.bottom, other.bottom),
+            type: 'left',
+            orientation: 'vertical',
+        });
+    }
+    // Center alignment
+    if (Math.abs(dragged.centerX - other.centerX) < tolerance) {
+        alignments.push({
+            x: dragged.centerX,
+            y1: Math.min(dragged.top, other.top),
+            y2: Math.max(dragged.bottom, other.bottom),
+            type: 'center',
+            orientation: 'vertical',
+        });
+    }
+    // Right alignment
+    if (Math.abs(dragged.right - other.right) < tolerance) {
+        alignments.push({
+            x: dragged.right,
+            y1: Math.min(dragged.top, other.top),
+            y2: Math.max(dragged.bottom, other.bottom),
+            type: 'right',
+            orientation: 'vertical',
+        });
+    }
+    // Cross-border: right of dragged with left of other
+    if (Math.abs(dragged.right - other.left) < tolerance) {
+        alignments.push({
+            x: dragged.right,
+            y1: Math.min(dragged.top, other.top),
+            y2: Math.max(dragged.bottom, other.bottom),
+            type: 'right',
+            orientation: 'vertical',
+        });
+    }
+    // Cross-border: left of dragged with right of other
+    if (Math.abs(dragged.left - other.right) < tolerance) {
+        alignments.push({
+            x: dragged.left,
+            y1: Math.min(dragged.top, other.top),
+            y2: Math.max(dragged.bottom, other.bottom),
+            type: 'left',
+            orientation: 'vertical',
+        });
+    }
+    // Horizontal lines (vertical alignment)
+    // Top alignment
+    if (Math.abs(dragged.top - other.top) < tolerance) {
+        alignments.push({
+            y: dragged.top,
+            x1: Math.min(dragged.left, other.left),
+            x2: Math.max(dragged.right, other.right),
+            type: 'top',
+            orientation: 'horizontal',
+        });
+    }
+    // Middle alignment
+    if (Math.abs(dragged.centerY - other.centerY) < tolerance) {
+        alignments.push({
+            y: dragged.centerY,
+            x1: Math.min(dragged.left, other.left),
+            x2: Math.max(dragged.right, other.right),
+            type: 'middle',
+            orientation: 'horizontal',
+        });
+    }
+    // Bottom alignment
+    if (Math.abs(dragged.bottom - other.bottom) < tolerance) {
+        alignments.push({
+            y: dragged.bottom,
+            x1: Math.min(dragged.left, other.left),
+            x2: Math.max(dragged.right, other.right),
+            type: 'bottom',
+            orientation: 'horizontal',
+        });
+    }
+    // Cross-border: bottom of dragged with top of other
+    if (Math.abs(dragged.bottom - other.top) < tolerance) {
+        alignments.push({
+            y: dragged.bottom,
+            x1: Math.min(dragged.left, other.left),
+            x2: Math.max(dragged.right, other.right),
+            type: 'bottom',
+            orientation: 'horizontal',
+        });
+    }
+    // Cross-border: top of dragged with bottom of other
+    if (Math.abs(dragged.top - other.bottom) < tolerance) {
+        alignments.push({
+            y: dragged.top,
+            x1: Math.min(dragged.left, other.left),
+            x2: Math.max(dragged.right, other.right),
+            type: 'top',
+            orientation: 'horizontal',
+        });
+    }
+    return alignments;
+}
+/**
+ * Calculate all alignment lines between a dragged element and multiple other elements.
+ *
+ * @param dragged - Relative bounds of the dragged element
+ * @param others - Array of relative bounds of other elements
+ * @param tolerance - Alignment tolerance in pixels (default: 0.5)
+ * @returns Array of all alignment lines
+ */
+function calculateAllAlignmentLines(dragged, others, tolerance = 0.5) {
+    const alignments = [];
+    for (const other of others) {
+        alignments.push(...calculateAlignmentLinesBetween(dragged, other, tolerance));
+    }
+    return alignments;
+}

package/dist/components/BannerRenderer/utils/elementCheckUtils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Element check utility functions for BannerRenderer
+ * Pure functions for checking element relationships (overlap, alignment)
+ */
+/**
+ * Check if two elements are overlapping vertically (one on top of the other).
+ *
+ * @param bounds1 - DOMRect of first element
+ * @param bounds2 - DOMRect of second element
+ * @returns True if elements have vertical overlap
+ */
+export declare function checkElementsOverlapping(bounds1: DOMRect, bounds2: DOMRect): boolean;
+/**
+ * Check if two elements are vertically aligned (one above the other).
+ *
+ * @param bounds1 - DOMRect of first element
+ * @param bounds2 - DOMRect of second element
+ * @param horizontalThreshold - Maximum horizontal distance between centers (default: 80px)
+ * @returns True if elements are vertically aligned
+ */
+export declare function checkVerticallyAligned(bounds1: DOMRect, bounds2: DOMRect, horizontalThreshold?: number): boolean;
+//# sourceMappingURL=elementCheckUtils.d.ts.map

package/dist/components/BannerRenderer/utils/elementCheckUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementCheckUtils.d.ts","sourceRoot":"","sources":["../../../../src/components/BannerRenderer/utils/elementCheckUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAOpF;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,mBAAmB,SAAK,GACvB,OAAO,CAST"}

package/dist/components/BannerRenderer/utils/elementCheckUtils.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Element check utility functions for BannerRenderer
+ * Pure functions for checking element relationships (overlap, alignment)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkElementsOverlapping = checkElementsOverlapping;
+exports.checkVerticallyAligned = checkVerticallyAligned;
+/**
+ * Check if two elements are overlapping vertically (one on top of the other).
+ *
+ * @param bounds1 - DOMRect of first element
+ * @param bounds2 - DOMRect of second element
+ * @returns True if elements have vertical overlap
+ */
+function checkElementsOverlapping(bounds1, bounds2) {
+    // Check if there's vertical overlap (not just touching)
+    // Overlap exists if one element starts before the other ends
+    return ((bounds1.top < bounds2.bottom && bounds1.bottom > bounds2.top) ||
+        (bounds2.top < bounds1.bottom && bounds2.bottom > bounds1.top));
+}
+/**
+ * Check if two elements are vertically aligned (one above the other).
+ *
+ * @param bounds1 - DOMRect of first element
+ * @param bounds2 - DOMRect of second element
+ * @param horizontalThreshold - Maximum horizontal distance between centers (default: 80px)
+ * @returns True if elements are vertically aligned
+ */
+function checkVerticallyAligned(bounds1, bounds2, horizontalThreshold = 80) {
+    // Calculate center X positions
+    const centerX1 = bounds1.left + bounds1.width / 2;
+    const centerX2 = bounds2.left + bounds2.width / 2;
+    // Elements are vertically aligned if their center X positions are close
+    const horizontalDiff = Math.abs(centerX1 - centerX2);
+    return horizontalDiff <= horizontalThreshold;
+}

package/dist/components/BannerRenderer/utils/elementIdUtils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Element ID utility functions for BannerRenderer
+ * Handles conversion between different ID formats
+ */
+import type { CopyConfig } from "../../../types";
+/**
+ * Convert element ID from copy-{uuid} to copy-{N} (styleSlot) format.
+ * This normalizes IDs to use the canonical copy-N format for storage in completedLines.
+ *
+ * @param elementId - Element ID in either format ('logo', 'copy-{uuid}', or 'copy-{N}')
+ * @param copies - Array of copy configurations
+ * @returns Normalized element ID in copy-N format
+ */
+export declare function convertToStyleSlotId(elementId: string, copies: CopyConfig[]): string;
+/**
+ * Parse element ID to extract the copy index or identify logo.
+ *
+ * @param elementId - Element ID ('logo' or 'copy-{N}')
+ * @returns Object with type and optional index
+ */
+export declare function parseElementId(elementId: string): {
+    type: 'logo' | 'copy';
+    index?: number;
+};
+//# sourceMappingURL=elementIdUtils.d.ts.map

package/dist/components/BannerRenderer/utils/elementIdUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementIdUtils.d.ts","sourceRoot":"","sources":["../../../../src/components/BannerRenderer/utils/elementIdUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,CAyBpF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAa3F"}

package/dist/components/BannerRenderer/utils/elementIdUtils.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Element ID utility functions for BannerRenderer
+ * Handles conversion between different ID formats
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToStyleSlotId = convertToStyleSlotId;
+exports.parseElementId = parseElementId;
+/**
+ * Convert element ID from copy-{uuid} to copy-{N} (styleSlot) format.
+ * This normalizes IDs to use the canonical copy-N format for storage in completedLines.
+ *
+ * @param elementId - Element ID in either format ('logo', 'copy-{uuid}', or 'copy-{N}')
+ * @param copies - Array of copy configurations
+ * @returns Normalized element ID in copy-N format
+ */
+function convertToStyleSlotId(elementId, copies) {
+    if (elementId === 'logo')
+        return 'logo';
+    if (elementId.startsWith('copy-')) {
+        const suffix = elementId.substring(5); // Remove 'copy-' prefix
+        // Check if it's already in copy-N format (just a number)
+        if (/^\d+$/.test(suffix)) {
+            return elementId; // Already in correct format
+        }
+        // It's a UUID format - find the copy and get its styleSlot
+        const copy = copies.find(c => c.id === suffix);
+        if ((copy === null || copy === void 0 ? void 0 : copy.styleSlot) !== undefined) {
+            return `copy-${copy.styleSlot}`;
+        }
+        // Fallback: use array index if styleSlot not defined
+        const copyIndex = copies.findIndex(c => c.id === suffix);
+        if (copyIndex !== -1) {
+            return `copy-${copyIndex}`;
+        }
+    }
+    return elementId;
+}
+/**
+ * Parse element ID to extract the copy index or identify logo.
+ *
+ * @param elementId - Element ID ('logo' or 'copy-{N}')
+ * @returns Object with type and optional index
+ */
+function parseElementId(elementId) {
+    if (elementId === 'logo') {
+        return { type: 'logo' };
+    }
+    if (elementId.startsWith('copy-')) {
+        const suffix = elementId.substring(5);
+        if (/^\d+$/.test(suffix)) {
+            return { type: 'copy', index: parseInt(suffix, 10) };
+        }
+    }
+    return { type: 'copy' };
+}

package/dist/components/BannerRenderer/utils/fontUtils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Font utility functions for BannerRenderer
+ */
+/**
+ * Convert font weight string to CSS numeric value.
+ * Supports both numeric strings ('400', '700') and named values ('thin', 'normal', 'bold').
+ *
+ * @param weight - Font weight as string (numeric or named)
+ * @returns CSS-compatible font weight value
+ */
+export declare function getFontWeight(weight: string): string;
+//# sourceMappingURL=fontUtils.d.ts.map

package/dist/components/BannerRenderer/utils/fontUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fontUtils.d.ts","sourceRoot":"","sources":["../../../../src/components/BannerRenderer/utils/fontUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAYpD"}

package/dist/components/BannerRenderer/utils/fontUtils.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Font utility functions for BannerRenderer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFontWeight = getFontWeight;
+/**
+ * Convert font weight string to CSS numeric value.
+ * Supports both numeric strings ('400', '700') and named values ('thin', 'normal', 'bold').
+ *
+ * @param weight - Font weight as string (numeric or named)
+ * @returns CSS-compatible font weight value
+ */
+function getFontWeight(weight) {
+    // If it's already a numeric string, return it directly
+    if (/^\d+$/.test(weight)) {
+        return weight;
+    }
+    // Otherwise, map old string values to numeric equivalents
+    switch (weight) {
+        case 'thin': return '300';
+        case 'normal': return '400';
+        case 'bold': return '700';
+        default: return '400';
+    }
+}

package/dist/components/BannerRenderer/utils/graphUtils.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Graph utility functions for BannerRenderer
+ * Union-Find data structure and proximity graph algorithms
+ */
+/**
+ * Union-Find (Disjoint Set) data structure with path compression
+ */
+export declare class UnionFind {
+    private parent;
+    constructor(elements: string[]);
+    /**
+     * Find the root of an element with path compression
+     */
+    find(id: string): string;
+    /**
+     * Union two elements into the same set
+     */
+    union(id1: string, id2: string): void;
+    /**
+     * Group all elements by their root (connected components)
+     */
+    getClusters(): Map<string, string[]>;
+}
+/**
+ * Calculate the distance between two DOMRects (edge-to-edge)
+ */
+export declare function calculateBoundsDistance(bounds1: DOMRect, bounds2: DOMRect): number;
+/**
+ * Build an adjacency graph based on proximity threshold.
+ * Returns a map where each element ID maps to a set of neighboring element IDs.
+ *
+ * @param elementBounds - Map of element IDs to their bounding rects
+ * @param proximityThreshold - Maximum distance (in pixels) to consider elements as neighbors
+ * @param sizeMultiplier - Size multiplier to scale the distance
+ * @returns Adjacency graph
+ */
+export declare function buildProximityGraph(elementBounds: Map<string, DOMRect>, proximityThreshold: number, sizeMultiplier?: number): Map<string, Set<string>>;
+/**
+ * Find connected clusters from an adjacency graph using Union-Find
+ *
+ * @param adjacencyGraph - Graph of element connections
+ * @returns Map of cluster root to array of element IDs in that cluster
+ */
+export declare function findConnectedClusters(adjacencyGraph: Map<string, Set<string>>): Map<string, string[]>;
+/**
+ * Create a linear chain of elements ordered by Y position within each cluster.
+ * Returns a map where each element (except the last in chain) points to the next.
+ *
+ * @param clusters - Map of cluster root to element IDs
+ * @param elementBounds - Map of element IDs to bounding rects
+ * @returns Map of sourceId to targetId representing the chain links
+ */
+export declare function createLinearChains(clusters: Map<string, string[]>, elementBounds: Map<string, DOMRect>): Map<string, string>;
+//# sourceMappingURL=graphUtils.d.ts.map

package/dist/components/BannerRenderer/utils/graphUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphUtils.d.ts","sourceRoot":"","sources":["../../../../src/components/BannerRenderer/utils/graphUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAsB;gBAExB,QAAQ,EAAE,MAAM,EAAE;IAK9B;;OAEG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAQxB;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAQrC;;OAEG;IACH,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;CAWrC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAYlF;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,kBAAkB,EAAE,MAAM,EAC1B,cAAc,SAAM,GACnB,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAyB1B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,GACvC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAYvB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC/B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAsBrB"}

package/dist/components/BannerRenderer/utils/graphUtils.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Graph utility functions for BannerRenderer
+ * Union-Find data structure and proximity graph algorithms
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionFind = void 0;
+exports.calculateBoundsDistance = calculateBoundsDistance;
+exports.buildProximityGraph = buildProximityGraph;
+exports.findConnectedClusters = findConnectedClusters;
+exports.createLinearChains = createLinearChains;
+/**
+ * Union-Find (Disjoint Set) data structure with path compression
+ */
+class UnionFind {
+    constructor(elements) {
+        this.parent = new Map();
+        elements.forEach(id => this.parent.set(id, id));
+    }
+    /**
+     * Find the root of an element with path compression
+     */
+    find(id) {
+        const p = this.parent.get(id);
+        if (p !== id) {
+            this.parent.set(id, this.find(p)); // Path compression
+        }
+        return this.parent.get(id);
+    }
+    /**
+     * Union two elements into the same set
+     */
+    union(id1, id2) {
+        const root1 = this.find(id1);
+        const root2 = this.find(id2);
+        if (root1 !== root2) {
+            this.parent.set(root2, root1);
+        }
+    }
+    /**
+     * Group all elements by their root (connected components)
+     */
+    getClusters() {
+        const clusters = new Map();
+        this.parent.forEach((_, id) => {
+            const root = this.find(id);
+            if (!clusters.has(root)) {
+                clusters.set(root, []);
+            }
+            clusters.get(root).push(id);
+        });
+        return clusters;
+    }
+}
+exports.UnionFind = UnionFind;
+/**
+ * Calculate the distance between two DOMRects (edge-to-edge)
+ */
+function calculateBoundsDistance(bounds1, bounds2) {
+    const dx = Math.max(bounds1.left - bounds2.right, bounds2.left - bounds1.right, 0);
+    const dy = Math.max(bounds1.top - bounds2.bottom, bounds2.top - bounds1.bottom, 0);
+    return Math.sqrt(dx * dx + dy * dy);
+}
+/**
+ * Build an adjacency graph based on proximity threshold.
+ * Returns a map where each element ID maps to a set of neighboring element IDs.
+ *
+ * @param elementBounds - Map of element IDs to their bounding rects
+ * @param proximityThreshold - Maximum distance (in pixels) to consider elements as neighbors
+ * @param sizeMultiplier - Size multiplier to scale the distance
+ * @returns Adjacency graph
+ */
+function buildProximityGraph(elementBounds, proximityThreshold, sizeMultiplier = 1.0) {
+    const adjacencyGraph = new Map();
+    const elementIds = Array.from(elementBounds.keys());
+    // Initialize graph
+    elementIds.forEach(id => adjacencyGraph.set(id, new Set()));
+    // Build edges based on proximity
+    for (let i = 0; i < elementIds.length; i++) {
+        for (let j = i + 1; j < elementIds.length; j++) {
+            const id1 = elementIds[i];
+            const id2 = elementIds[j];
+            const bounds1 = elementBounds.get(id1);
+            const bounds2 = elementBounds.get(id2);
+            const distance = calculateBoundsDistance(bounds1, bounds2) / sizeMultiplier;
+            if (distance <= proximityThreshold) {
+                adjacencyGraph.get(id1).add(id2);
+                adjacencyGraph.get(id2).add(id1);
+            }
+        }
+    }
+    return adjacencyGraph;
+}
+/**
+ * Find connected clusters from an adjacency graph using Union-Find
+ *
+ * @param adjacencyGraph - Graph of element connections
+ * @returns Map of cluster root to array of element IDs in that cluster
+ */
+function findConnectedClusters(adjacencyGraph) {
+    const elementIds = Array.from(adjacencyGraph.keys());
+    const uf = new UnionFind(elementIds);
+    // Build clusters by unioning connected elements
+    elementIds.forEach(id => {
+        adjacencyGraph.get(id).forEach(neighbor => {
+            uf.union(id, neighbor);
+        });
+    });
+    return uf.getClusters();
+}
+/**
+ * Create a linear chain of elements ordered by Y position within each cluster.
+ * Returns a map where each element (except the last in chain) points to the next.
+ *
+ * @param clusters - Map of cluster root to element IDs
+ * @param elementBounds - Map of element IDs to bounding rects
+ * @returns Map of sourceId to targetId representing the chain links
+ */
+function createLinearChains(clusters, elementBounds) {
+    const chains = new Map();
+    clusters.forEach((clusterElements) => {
+        if (clusterElements.length < 2)
+            return; // Single element, no chain needed
+        // Sort by Y position (top to bottom)
+        const sorted = [...clusterElements].sort((id1, id2) => {
+            const bounds1 = elementBounds.get(id1);
+            const bounds2 = elementBounds.get(id2);
+            const y1 = bounds1.top + bounds1.height / 2;
+            const y2 = bounds2.top + bounds2.height / 2;
+            return y1 - y2;
+        });
+        // Create sequential links
+        for (let i = 0; i < sorted.length - 1; i++) {
+            chains.set(sorted[i], sorted[i + 1]);
+        }
+    });
+    return chains;
+}

package/dist/components/BannerRenderer/utils/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * BannerRenderer utility functions
+ */
+export { getFontWeight } from './fontUtils';
+export { snapRotation, toRelativeBounds, calculateSnapDelta } from './snapUtils';
+export type { RelativeBounds } from './snapUtils';
+export { convertToStyleSlotId, parseElementId } from './elementIdUtils';
+export { checkElementsOverlapping, checkVerticallyAligned } from './elementCheckUtils';
+export { calculateAlignmentLinesBetween, calculateAllAlignmentLines } from './alignmentUtils';
+export type { AlignmentLine } from './alignmentUtils';
+export { UnionFind, calculateBoundsDistance, buildProximityGraph, findConnectedClusters, createLinearChains } from './graphUtils';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/BannerRenderer/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/BannerRenderer/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjF,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,8BAA8B,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAC9F,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC"}

package/dist/components/BannerRenderer/utils/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * BannerRenderer utility functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinearChains = exports.findConnectedClusters = exports.buildProximityGraph = exports.calculateBoundsDistance = exports.UnionFind = exports.calculateAllAlignmentLines = exports.calculateAlignmentLinesBetween = exports.checkVerticallyAligned = exports.checkElementsOverlapping = exports.parseElementId = exports.convertToStyleSlotId = exports.calculateSnapDelta = exports.toRelativeBounds = exports.snapRotation = exports.getFontWeight = void 0;
+var fontUtils_1 = require("./fontUtils");
+Object.defineProperty(exports, "getFontWeight", { enumerable: true, get: function () { return fontUtils_1.getFontWeight; } });
+var snapUtils_1 = require("./snapUtils");
+Object.defineProperty(exports, "snapRotation", { enumerable: true, get: function () { return snapUtils_1.snapRotation; } });
+Object.defineProperty(exports, "toRelativeBounds", { enumerable: true, get: function () { return snapUtils_1.toRelativeBounds; } });
+Object.defineProperty(exports, "calculateSnapDelta", { enumerable: true, get: function () { return snapUtils_1.calculateSnapDelta; } });
+var elementIdUtils_1 = require("./elementIdUtils");
+Object.defineProperty(exports, "convertToStyleSlotId", { enumerable: true, get: function () { return elementIdUtils_1.convertToStyleSlotId; } });
+Object.defineProperty(exports, "parseElementId", { enumerable: true, get: function () { return elementIdUtils_1.parseElementId; } });
+var elementCheckUtils_1 = require("./elementCheckUtils");
+Object.defineProperty(exports, "checkElementsOverlapping", { enumerable: true, get: function () { return elementCheckUtils_1.checkElementsOverlapping; } });
+Object.defineProperty(exports, "checkVerticallyAligned", { enumerable: true, get: function () { return elementCheckUtils_1.checkVerticallyAligned; } });
+var alignmentUtils_1 = require("./alignmentUtils");
+Object.defineProperty(exports, "calculateAlignmentLinesBetween", { enumerable: true, get: function () { return alignmentUtils_1.calculateAlignmentLinesBetween; } });
+Object.defineProperty(exports, "calculateAllAlignmentLines", { enumerable: true, get: function () { return alignmentUtils_1.calculateAllAlignmentLines; } });
+var graphUtils_1 = require("./graphUtils");
+Object.defineProperty(exports, "UnionFind", { enumerable: true, get: function () { return graphUtils_1.UnionFind; } });
+Object.defineProperty(exports, "calculateBoundsDistance", { enumerable: true, get: function () { return graphUtils_1.calculateBoundsDistance; } });
+Object.defineProperty(exports, "buildProximityGraph", { enumerable: true, get: function () { return graphUtils_1.buildProximityGraph; } });
+Object.defineProperty(exports, "findConnectedClusters", { enumerable: true, get: function () { return graphUtils_1.findConnectedClusters; } });
+Object.defineProperty(exports, "createLinearChains", { enumerable: true, get: function () { return graphUtils_1.createLinearChains; } });

package/dist/components/BannerRenderer/utils/snapUtils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Snap utility functions for BannerRenderer
+ * Pure functions for snapping positions and rotations
+ */
+/**
+ * Snap angle to nearest cardinal direction (0°, 90°, 180°, 270°)
+ * @param angle - Input angle in degrees
+ * @param snapThreshold - Degrees threshold for snapping (default: 3)
+ * @returns Snapped angle or normalized input angle
+ */
+export declare function snapRotation(angle: number, snapThreshold?: number): number;
+/**
+ * Element bounds relative to a container center
+ */
+export interface RelativeBounds {
+    left: number;
+    centerX: number;
+    right: number;
+    top: number;
+    centerY: number;
+    bottom: number;
+}
+/**
+ * Convert DOMRect to relative bounds (relative to container center)
+ */
+export declare function toRelativeBounds(bounds: DOMRect, containerBounds: DOMRect, sizeMultiplier: number): RelativeBounds;
+/**
+ * Calculate snap delta for position alignment
+ * @param draggedBounds - Bounds of the element being dragged
+ * @param otherBoundsArray - Array of other elements' bounds to snap to
+ * @param snapThreshold - Pixel threshold for snapping (default: 5)
+ * @returns Delta to apply to position for snapping
+ */
+export declare function calculateSnapDelta(draggedBounds: RelativeBounds, otherBoundsArray: RelativeBounds[], snapThreshold?: number): {
+    deltaX: number;
+    deltaY: number;
+};
+//# sourceMappingURL=snapUtils.d.ts.map

package/dist/components/BannerRenderer/utils/snapUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapUtils.d.ts","sourceRoot":"","sources":["../../../../src/components/BannerRenderer/utils/snapUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,SAAI,GAAG,MAAM,CAgBrE;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,OAAO,EACf,eAAe,EAAE,OAAO,EACxB,cAAc,EAAE,MAAM,GACrB,cAAc,CAShB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,cAAc,EAC7B,gBAAgB,EAAE,cAAc,EAAE,EAClC,aAAa,SAAI,GAChB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAoDpC"}