@finsweet/webflow-apps-utils 1.0.4 → 1.0.5

package/dist/utils/diff-mapper/DiffMapperDemo.svelte

@@ -0,0 +1,351 @@
+<script lang="ts">
+	import { getDetailedDiff, hasChangesViaDiff } from '../../providers/configuratorUtils';
+
+	let output = '';
+	let coercionExamples = '';
+	let performanceResults = '';
+	let deepOutput = '';
+
+	function runDiffExamples() {
+		// Example 1: Basic object comparison
+		const obj1 = { name: 'John', age: 30, active: 'true' };
+		const obj2 = { name: 'John', age: 31, active: true };
+
+		// @ts-expect-error - intentional type mismatch for demo
+		const hasChanges = hasChangesViaDiff(obj1, obj2);
+		// @ts-expect-error - intentional type mismatch for demo
+		const detailedDiff = getDetailedDiff(obj1, obj2);
+
+		// Example 2: Nested object comparison
+		const nested1 = {
+			user: { profile: { name: 'John', settings: { theme: 'dark' } } },
+			items: [{ id: 1, name: 'Item 1' }]
+		};
+
+		const nested2 = {
+			user: { profile: { name: 'John', settings: { theme: 'light' } } },
+			items: [
+				{ id: 1, name: 'Item 1' },
+				{ id: 2, name: 'Item 2' }
+			]
+		};
+
+		const nestedChanges = hasChangesViaDiff(nested1, nested2);
+		const nestedDiff = getDetailedDiff(nested1, nested2);
+
+		// Example 3: Type coercion examples
+		const coercion1 = { count: '5', enabled: '', value: '0' };
+		const coercion2 = { count: 5, enabled: false, value: 0 };
+		// @ts-expect-error - intentional type mismatch for demo
+		const coercionChanges = hasChangesViaDiff(coercion1, coercion2);
+
+		output = `
+📊 DIFF MAPPER RESULTS
+
+1. Basic Object Comparison:
+   Object 1: ${JSON.stringify(obj1)}
+   Object 2: ${JSON.stringify(obj2)}
+   Has Changes: ${hasChanges}
+   Age changed from 30 to 31, but 'true' === true (type coercion)
+
+2. Nested Object Comparison:
+   Has Changes: ${nestedChanges}
+   Theme changed from 'dark' to 'light'
+   New item added to array
+
+3. Type Coercion Examples:
+   Object 1: ${JSON.stringify(coercion1)}
+   Object 2: ${JSON.stringify(coercion2)}
+   Has Changes: ${coercionChanges}
+   All values are equivalent due to intelligent type coercion!
+
+📝 Check the browser console for detailed diff objects.
+		`;
+
+		// Log detailed results to console
+		console.group('🔍 DiffMapper Detailed Results');
+		console.log('Basic diff:', detailedDiff);
+		console.log('Nested diff:', nestedDiff);
+		console.groupEnd();
+	}
+
+	function generateCoercionExamples() {
+		const examples = [
+			[{ value: '42' }, { value: 42 }, 'String "42" equals number 42'],
+			[{ active: 'true' }, { active: true }, 'String "true" equals boolean true'],
+			[{ empty: '' }, { empty: 0 }, 'Empty string equals number 0'],
+			[{ name: 'John' }, { name: '  John  ' }, 'Whitespace is trimmed'],
+			[{ enabled: 'false' }, { enabled: false }, 'String "false" equals boolean false']
+		];
+
+		let html = '<div style="display: grid; gap: 10px;">';
+
+		examples.forEach(([obj1, obj2, description]) => {
+			const hasChanges = hasChangesViaDiff(obj1, obj2);
+			const status = hasChanges ? '❌ DIFFERENT' : '✅ SAME';
+			const color = hasChanges ? 'var(--redText)' : 'var(--greenText)';
+
+			html += `
+				<div class="coercion-example">
+					<div style="color: ${color}; font-weight: var(--font-weight-medium); margin-bottom: var(--spacing-4);">${status}</div>
+					<div style="color: var(--text1);"><strong>A:</strong> ${JSON.stringify(obj1)}</div>
+					<div style="color: var(--text1);"><strong>B:</strong> ${JSON.stringify(obj2)}</div>
+					<div style="color: var(--text3); font-style: italic; margin-top: var(--spacing-4);">${description}</div>
+				</div>
+			`;
+		});
+
+		html += '</div>';
+		coercionExamples = html;
+	}
+
+	function runPerformanceTest() {
+		// Create large objects for testing
+		const createLargeObject = (size: number) => {
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const obj: Record<string, any> = {};
+			for (let i = 0; i < size; i++) {
+				obj[`key${i}`] = {
+					id: i,
+					name: `Item ${i}`,
+					nested: {
+						value: Math.random(),
+						timestamp: Date.now()
+					}
+				};
+			}
+			return obj;
+		};
+
+		const obj1 = createLargeObject(100);
+		const obj2 = { ...obj1 };
+		obj2.key50.nested.value = 999; // Change one value
+
+		// Measure performance
+		const start = performance.now();
+		const hasChanges = hasChangesViaDiff(obj1, obj2);
+		const end = performance.now();
+
+		// Test caching - second call should be faster
+		const start2 = performance.now();
+		hasChangesViaDiff(obj1, obj2);
+		const end2 = performance.now();
+
+		performanceResults = `
+			<div class="performance-result">
+				<h4>Performance Test Results</h4>
+				<div><strong>Object Size:</strong> 100 nested objects</div>
+				<div><strong>Change Detected:</strong> ${hasChanges ? 'Yes' : 'No'}</div>
+				<div><strong>First Call:</strong> ${(end - start).toFixed(2)}ms</div>
+				<div><strong>Cached Call:</strong> ${(end2 - start2).toFixed(2)}ms</div>
+				<div style="color: var(--greenText); margin-top: var(--spacing-12); font-weight: var(--font-weight-medium);">
+					⚡ ${((end - start) / (end2 - start2)).toFixed(1)}x faster with caching!
+				</div>
+			</div>
+		`;
+
+		console.log('Performance test completed:', {
+			hasChanges,
+			firstCall: end - start,
+			cachedCall: end2 - start2,
+			speedup: (end - start) / (end2 - start2)
+		});
+	}
+
+	function runDeepTest() {
+		const deepObj1 = {
+			level1: {
+				level2: {
+					level3: {
+						level4: {
+							data: 'original',
+							count: 42,
+							items: [1, 2, 3]
+						}
+					}
+				}
+			}
+		};
+
+		const deepObj2 = {
+			level1: {
+				level2: {
+					level3: {
+						level4: {
+							data: 'modified',
+							count: 42,
+							items: [1, 2, 3, 4]
+						}
+					}
+				}
+			}
+		};
+
+		const hasChanges = hasChangesViaDiff(deepObj1, deepObj2);
+		const diff = getDetailedDiff(deepObj1, deepObj2);
+
+		deepOutput = `
+Deep Object Comparison Results:
+
+Has Changes: ${hasChanges}
+
+Changes detected:
+- level1.level2.level3.level4.data: "original" → "modified"
+- level1.level2.level3.level4.items: Array length changed (3 → 4)
+
+The diff mapper successfully navigated 4 levels deep to detect specific changes!
+
+See console for the complete diff structure.
+		`;
+
+		console.log('Deep nesting diff:', diff);
+	}
+</script>
+
+<div class="demo-container">
+	<h3>DiffMapper Utilities Demo</h3>
+	<p>Open the browser console to see diff results.</p>
+	<button class="btn btn--primary" onclick={runDiffExamples}>Run Diff Examples</button>
+	<pre class="output-block">{output}</pre>
+
+	<hr class="divider" />
+
+	<h3>Type Coercion Examples</h3>
+	<button class="btn btn--primary" onclick={generateCoercionExamples}>Show Type Coercion</button>
+	<div class="examples-container">
+		{@html coercionExamples}
+	</div>
+
+	<hr class="divider" />
+
+	<h3>Performance Features</h3>
+	<button class="btn btn--primary" onclick={runPerformanceTest}>Run Performance Test</button>
+	<div class="results-container">
+		{@html performanceResults}
+	</div>
+
+	<hr class="divider" />
+
+	<h3>Deep Nesting Comparison</h3>
+	<button class="btn btn--primary" onclick={runDeepTest}>Test Deep Objects</button>
+	<pre class="output-block small">{deepOutput}</pre>
+</div>
+
+<style>
+	.demo-container {
+		padding: var(--spacing-24);
+		font-family: var(--font-stack);
+		background: var(--background1);
+		color: var(--text1);
+		max-width: 800px;
+		margin: 0 auto;
+	}
+
+	h3 {
+		color: var(--text1);
+		font-size: var(--font-size-large);
+		font-weight: var(--font-weight-medium);
+		margin: var(--spacing-16) 0 var(--spacing-8) 0;
+	}
+
+	p {
+		color: var(--text2);
+		font-size: var(--font-size-small);
+		margin: var(--spacing-8) 0;
+	}
+
+	.btn {
+		padding: var(--padding-small) var(--padding-regular);
+		border: none;
+		border-radius: var(--border-radius);
+		cursor: pointer;
+		font-size: var(--font-size-small);
+		font-weight: var(--font-weight-normal);
+		font-family: var(--font-stack);
+		transition: all 0.2s ease;
+		margin: var(--spacing-8) 0;
+	}
+
+	.btn--primary {
+		background: var(--actionPrimaryBackground);
+		color: var(--actionPrimaryText);
+		box-shadow: var(--boxShadows-action-colored);
+	}
+
+	.btn--primary:hover {
+		background: var(--actionPrimaryBackgroundHover);
+		color: var(--actionPrimaryTextHover);
+	}
+
+	.output-block {
+		background: var(--background2);
+		border: 1px solid var(--border2);
+		padding: var(--spacing-12);
+		margin-top: var(--spacing-12);
+		white-space: pre-wrap;
+		border-radius: var(--border-radius);
+		font-family: monospace;
+		color: var(--text2);
+		font-size: var(--font-size-small);
+	}
+
+	.output-block.small {
+		font-size: var(--font-size-small);
+	}
+
+	.divider {
+		border: none;
+		border-top: 1px solid var(--border2);
+		margin: var(--spacing-32) 0;
+	}
+
+	.examples-container,
+	.results-container {
+		margin-top: var(--spacing-16);
+	}
+
+	/* Dynamic HTML content styling */
+	:global(.examples-container > div) {
+		display: grid;
+		gap: var(--spacing-12);
+	}
+
+	:global(.coercion-example) {
+		padding: var(--spacing-12);
+		border: 1px solid var(--border2);
+		border-radius: var(--border-radius);
+		background: var(--background2);
+	}
+
+	:global(.performance-result) {
+		background: var(--background2);
+		border: 1px solid var(--border2);
+		padding: var(--spacing-16);
+		border-radius: var(--border-radius);
+	}
+
+	:global(.results-container > div) {
+		background: var(--background2);
+		border: 1px solid var(--border2);
+		padding: var(--spacing-16);
+		border-radius: var(--border-radius);
+	}
+
+	:global(.results-container h4) {
+		color: var(--text1);
+		font-size: var(--font-size-large);
+		font-weight: var(--font-weight-medium);
+		margin: 0 0 var(--spacing-8) 0;
+	}
+
+	:global(.results-container div) {
+		color: var(--text2);
+		font-size: var(--font-size-small);
+		margin: var(--spacing-4) 0;
+	}
+
+	:global(.results-container strong) {
+		color: var(--text1);
+		font-weight: var(--font-weight-medium);
+	}
+</style>

package/dist/utils/diff-mapper/DiffMapperDemo.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const DiffMapperDemo: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type DiffMapperDemo = InstanceType<typeof DiffMapperDemo>;
+export default DiffMapperDemo;

package/dist/utils/diff-mapper/deepDiffMapper.d.ts

@@ -0,0 +1,31 @@
+export declare enum DiffType {
+    CREATED = "created",
+    UPDATED = "updated",
+    DELETED = "deleted",
+    UNCHANGED = "unchanged"
+}
+export interface DiffResult {
+    type: DiffType;
+    data: any;
+}
+export type DiffMap = {
+    [key: string]: DiffResult | DiffMap;
+};
+export type ComparableValue = any;
+declare class DeepDiffMapper {
+    private visitedPairs;
+    private isFunction;
+    private isArray;
+    private isDate;
+    private isObject;
+    private isValue;
+    private compareValues;
+    private areEquivalentPrimitives;
+    private hasCircularReference;
+    private _map;
+    map(obj1: ComparableValue, obj2: ComparableValue): DiffResult | DiffMap;
+    compare(obj1: ComparableValue, obj2: ComparableValue): DiffResult | DiffMap;
+}
+export declare const deepDiffMapper: DeepDiffMapper;
+export { DeepDiffMapper };
+export declare function compareObjects(obj1: ComparableValue, obj2: ComparableValue): DiffResult | DiffMap;

package/dist/utils/diff-mapper/deepDiffMapper.js

@@ -0,0 +1,264 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export var DiffType;
+(function (DiffType) {
+    DiffType["CREATED"] = "created";
+    DiffType["UPDATED"] = "updated";
+    DiffType["DELETED"] = "deleted";
+    DiffType["UNCHANGED"] = "unchanged";
+})(DiffType || (DiffType = {}));
+class DeepDiffMapper {
+    visitedPairs = new WeakMap();
+    isFunction(x) {
+        return Object.prototype.toString.call(x) === '[object Function]';
+    }
+    isArray(x) {
+        return Object.prototype.toString.call(x) === '[object Array]';
+    }
+    isDate(x) {
+        return Object.prototype.toString.call(x) === '[object Date]';
+    }
+    isObject(x) {
+        return Object.prototype.toString.call(x) === '[object Object]';
+    }
+    isValue(x) {
+        return !this.isObject(x) && !this.isArray(x);
+    }
+    compareValues(value1, value2) {
+        if (value1 === value2 || this.areEquivalentPrimitives(value1, value2)) {
+            return DiffType.UNCHANGED;
+        }
+        if (this.isDate(value1) && this.isDate(value2) && value1.getTime() === value2.getTime()) {
+            return DiffType.UNCHANGED;
+        }
+        if (value1 === undefined) {
+            return DiffType.CREATED;
+        }
+        if (value2 === undefined) {
+            return DiffType.DELETED;
+        }
+        return DiffType.UPDATED;
+    }
+    areEquivalentPrimitives(value1, value2) {
+        // Handle null and undefined
+        if (value1 == null && value2 == null) {
+            return true;
+        }
+        // Handle string trimming - if both are strings, compare trimmed versions
+        if (typeof value1 === 'string' && typeof value2 === 'string') {
+            return value1.trim() === value2.trim();
+        }
+        // Handle string/boolean coercion with specific string values
+        if ((typeof value1 === 'string' || typeof value1 === 'boolean') &&
+            (typeof value2 === 'string' || typeof value2 === 'boolean')) {
+            const val1 = typeof value1 === 'string' ? value1.trim().toLowerCase() : value1;
+            const val2 = typeof value2 === 'string' ? value2.trim().toLowerCase() : value2;
+            // Handle specific string-boolean equivalences
+            if (typeof val1 === 'string' && typeof val2 === 'boolean') {
+                if ((val1 === 'true' && val2 === true) || (val1 === 'false' && val2 === false)) {
+                    return true;
+                }
+                // Handle empty string as false
+                if (val1 === '' && val2 === false) {
+                    return true;
+                }
+            }
+            if (typeof val2 === 'string' && typeof val1 === 'boolean') {
+                if ((val2 === 'true' && val1 === true) || (val2 === 'false' && val1 === false)) {
+                    return true;
+                }
+                // Handle empty string as false
+                if (val2 === '' && val1 === false) {
+                    return true;
+                }
+            }
+        }
+        // Handle string/number coercion
+        if ((typeof value1 === 'string' || typeof value1 === 'number') &&
+            (typeof value2 === 'string' || typeof value2 === 'number')) {
+            // For string to number comparison, trim the string first
+            const str1 = typeof value1 === 'string' ? value1.trim() : value1.toString();
+            const str2 = typeof value2 === 'string' ? value2.trim() : value2.toString();
+            // Only treat truly empty strings (not whitespace-only) as equivalent to 0
+            // Distinguish between empty string ('') and whitespace-only strings (' ', '  ')
+            if (typeof value1 === 'string' && value1 === '' && typeof value2 === 'number') {
+                return value2 === 0;
+            }
+            if (typeof value2 === 'string' && value2 === '' && typeof value1 === 'number') {
+                return value1 === 0;
+            }
+            // Don't treat whitespace-only strings as equivalent to numbers
+            if (typeof value1 === 'string' && value1.trim() === '' && value1 !== '') {
+                return false; // ' ', '  ', etc. should not be equivalent to numbers
+            }
+            if (typeof value2 === 'string' && value2.trim() === '' && value2 !== '') {
+                return false; // ' ', '  ', etc. should not be equivalent to numbers
+            }
+            // Convert both to numbers and compare
+            const num1 = Number(str1);
+            const num2 = Number(str2);
+            // Handle NaN case specifically - only consider equal if both are exactly NaN
+            if (isNaN(num1) || isNaN(num2)) {
+                return Number.isNaN(value1) && Number.isNaN(value2);
+            }
+            if (!isNaN(num1) && !isNaN(num2)) {
+                return num1 === num2;
+            }
+        }
+        return false;
+    }
+    hasCircularReference(obj1, obj2) {
+        if (typeof obj1 !== 'object' || typeof obj2 !== 'object' || obj1 === null || obj2 === null) {
+            return false;
+        }
+        if (!this.visitedPairs.has(obj1)) {
+            this.visitedPairs.set(obj1, new WeakSet());
+        }
+        const visited = this.visitedPairs.get(obj1);
+        if (visited.has(obj2)) {
+            return true;
+        }
+        visited.add(obj2);
+        return false;
+    }
+    _map(obj1, obj2) {
+        if (this.isFunction(obj1) || this.isFunction(obj2)) {
+            throw new Error('Invalid argument. Function given, object expected.');
+        }
+        // Only treat as values if both are values, or if one is undefined and the other is also a value
+        // This prevents treating undefined vs complex object as a value comparison
+        if (this.isValue(obj1) && this.isValue(obj2)) {
+            const diffType = this.compareValues(obj1, obj2);
+            return {
+                type: diffType,
+                data: diffType === DiffType.CREATED ? obj2 : obj1
+            };
+        }
+        // Special case: one is undefined/null and the other is a complex object
+        if ((obj1 === undefined || obj1 === null) && (this.isArray(obj2) || this.isObject(obj2))) {
+            // Recursively process the non-undefined object as if it was created
+            return this._map({}, obj2);
+        }
+        if ((obj2 === undefined || obj2 === null) && (this.isArray(obj1) || this.isObject(obj1))) {
+            // Recursively process the non-undefined object as if it was deleted
+            return this._map(obj1, {});
+        }
+        // Handle primitive value cases (one or both are primitives but not both complex)
+        if (this.isValue(obj1) || this.isValue(obj2)) {
+            const diffType = this.compareValues(obj1, obj2);
+            return {
+                type: diffType,
+                data: diffType === DiffType.CREATED ? obj2 : obj1
+            };
+        }
+        // Check if both are complex types but of different specific types (array vs object)
+        const isArrayVsObject = (this.isArray(obj1) && this.isObject(obj2)) || (this.isObject(obj1) && this.isArray(obj2));
+        // For mixed types (array vs object), check if they have the same structure first
+        if (isArrayVsObject) {
+            // If both are empty, they're still different types
+            const keys1 = Object.keys(obj1 || {});
+            const keys2 = Object.keys(obj2 || {});
+            if (keys1.length === 0 && keys2.length === 0) {
+                return {
+                    type: DiffType.UPDATED,
+                    data: obj1
+                };
+            }
+            // Continue with property comparison for non-empty mixed types
+        }
+        // Check for circular references
+        if (this.hasCircularReference(obj1, obj2)) {
+            return {
+                type: DiffType.UNCHANGED,
+                data: obj1
+            };
+        }
+        const diff = {};
+        // Get all property keys including symbols and own properties
+        const getAllKeys = (obj) => {
+            if (!obj)
+                return [];
+            const keys = [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj)];
+            // Include inherited enumerable properties
+            for (const key in obj) {
+                if (!keys.includes(key)) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        };
+        const keys1 = getAllKeys(obj1);
+        const keys2 = getAllKeys(obj2);
+        const allKeys = new Set([...keys1, ...keys2]);
+        // Check if prototypes are different and add __proto__ to comparison
+        const proto1 = obj1 ? Object.getPrototypeOf(obj1) : null;
+        const proto2 = obj2 ? Object.getPrototypeOf(obj2) : null;
+        // Add __proto__ to comparison if prototypes differ
+        if (proto1 !== proto2) {
+            allKeys.add('__proto__');
+        }
+        // Check all properties from both objects
+        for (const key of allKeys) {
+            if (this.isFunction(obj1?.[key]) || this.isFunction(obj2?.[key])) {
+                continue;
+            }
+            let value1;
+            let value2;
+            // Special handling for __proto__
+            if (key === '__proto__') {
+                // We already know prototypes differ if we got here (since we added __proto__ to allKeys)
+                // For prototypes, we'll do a shallow comparison to avoid infinite recursion
+                if (proto1 === proto2) {
+                    continue; // Should not happen since we only added this key when they differ
+                }
+                // Compare prototypes - treat default Object.prototype as "undefined" for comparison purposes
+                const isDefaultProto1 = proto1 === Object.prototype || proto1 === null;
+                const isDefaultProto2 = proto2 === Object.prototype || proto2 === null;
+                // If one has default prototype and other has custom, treat as create/delete
+                if (isDefaultProto1 && !isDefaultProto2) {
+                    diff[key] = {
+                        type: DiffType.CREATED,
+                        data: proto2
+                    };
+                    continue;
+                }
+                if (!isDefaultProto1 && isDefaultProto2) {
+                    diff[key] = {
+                        type: DiffType.DELETED,
+                        data: proto1
+                    };
+                    continue;
+                }
+                // Both have custom prototypes but they're different
+                if (!isDefaultProto1 && !isDefaultProto2 && proto1 !== proto2) {
+                    diff[key] = {
+                        type: DiffType.UPDATED,
+                        data: proto1
+                    };
+                    continue;
+                }
+            }
+            else {
+                value1 = obj1?.[key];
+                value2 = obj2?.[key];
+            }
+            diff[key] = this._map(value1, value2);
+        }
+        return diff;
+    }
+    map(obj1, obj2) {
+        // Reset visited pairs for each new comparison
+        this.visitedPairs = new WeakMap();
+        return this._map(obj1, obj2);
+    }
+    compare(obj1, obj2) {
+        return this.map(obj1, obj2);
+    }
+}
+// Export singleton instance
+export const deepDiffMapper = new DeepDiffMapper();
+// Export class for custom instances if needed
+export { DeepDiffMapper };
+// Export convenience function
+export function compareObjects(obj1, obj2) {
+    return deepDiffMapper.compare(obj1, obj2);
+}

package/dist/utils/diff-mapper/index.d.ts

@@ -0,0 +1 @@
+export * from './deepDiffMapper';

package/dist/utils/diff-mapper/index.js

@@ -0,0 +1 @@
+export * from './deepDiffMapper';

package/dist/utils/index.d.ts

@@ -4,6 +4,7 @@ export * from './auth';
 export * from './browser-storage';
 export * from './constants';
 export * from './custom-code';
+export * from './diff-mapper';
 export * from './helpers';
 export * from './logger';
 export * from './webflow-canvas';

package/dist/utils/index.js

@@ -4,6 +4,7 @@ export * from './auth';
 export * from './browser-storage';
 export * from './constants';
 export * from './custom-code';
+export * from './diff-mapper';
 export * from './helpers';
 export * from './logger';
 export * from './webflow-canvas';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finsweet/webflow-apps-utils",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Shared utilities for Webflow apps",
   "homepage": "https://github.com/finsweet/webflow-apps-utils",
   "repository": {