inviton-powerduck 0.0.331 → 0.0.332

package/app/powerduck-system-resources.ts

@@ -37,6 +37,7 @@ export interface IPowerduckSystemResources {
 	fileDownloadTitle: string;
 	imageCrop: string;
 	uploadImage: string;
+	uploadFailed: string;
 	copyToClipboard: string;
 	copyToClipboardSuccess: string;
 	loginExpired: string;

package/common/utils/file-helper.ts

@@ -3,16 +3,32 @@ import PowerduckState from '../../app/powerduck-state';
 import { AppHttpProvider } from '../api-http';
 import { DomainHelper } from './domain-helper';
 
+const ABSOLUTE_URL_RE = /^https?:\/\//i;
+const LEADING_SLASH_ABSOLUTE_RE = /^\/https?:\/\//i;
+
 export default class FileHelper {
 	static getFullPath(file: Photo) {
-		if (file == null) {
+		if (file == null || file.path == null) {
 			return null;
 		}
 
+		const rawPath = file.path.trim();
+
+		// 1. Already-absolute URL (Bunny CDN, S3, data:, protocol-relative) — return as-is.
+		if (ABSOLUTE_URL_RE.test(rawPath) || rawPath.startsWith('//') || rawPath.startsWith('data:')) {
+			return rawPath;
+		}
+
+		// 2. Stray leading-slash before scheme ("/https://..."): strip the slash.
+		if (LEADING_SLASH_ABSOLUTE_RE.test(rawPath)) {
+			return rawPath.slice(1);
+		}
+
+		// 3. Legacy relative path (e.g. "/photos/resorts/file.png") — resolve against backend domain.
 		if (AppHttpProvider.enforceDomain == '/') {
-			return PowerduckState.getCdnPath() + PowerduckState.getFilesPath() + file.path;
+			return PowerduckState.getCdnPath() + PowerduckState.getFilesPath() + rawPath;
 		}
 
-		return DomainHelper.getDomainFromUrl(AppHttpProvider.enforceDomain, true) + PowerduckState.getFilesPath() + file.path;
+		return DomainHelper.getDomainFromUrl(AppHttpProvider.enforceDomain, true) + PowerduckState.getFilesPath() + rawPath;
 	}
 }

package/common/utils/upload-image-helper.ts

@@ -1,6 +1,7 @@
 import type { ImageResponse, OnUploadImageResponse } from '../../data/image';
 import { globalState } from '../../app/global-state';
 import PowerduckState from '../../app/powerduck-state';
+import NotificationProvider from '../../components/ui/notification';
 import { AppHttpProvider } from '../api-http';
 import { BrowserImageCompression } from './broswer-image-compression';
 import { isNullOrEmpty } from './is-null-or-empty';
@@ -25,7 +26,7 @@ export class UploadImageHelper {
         disableCompression: boolean = false,
         compressionMaxMb: number = 0.5,
         url?: string,
-	): Promise<ImageResponse> {
+	): Promise<ImageResponse | null> {
 		if (!(disableCompression || file.type == 'image/svg+xml')) {
 			file = await BrowserImageCompression.compress(file, {
 				maxSizeMB: compressionMaxMb,
@@ -49,6 +50,12 @@ export class UploadImageHelper {
 			credentials: UploadImageHelperConfig.includeCredentials ? PowerduckState.getIsDebugMode() ? 'include' : 'same-origin' : 'omit',
 		});
 
+		if (!response.ok) {
+			NotificationProvider.showErrorMessage(PowerduckState.getResourceValue('uploadFailed'));
+
+			return null;
+		}
+
 		return (await response.json()) as ImageResponse;
 	}
 

package/components/input/gps-bounding-box.tsx

@@ -32,6 +32,10 @@ class GpsBoundingBoxInputComponent extends TsxComponent<GpsBoundingBoxInputArgs>
 
 	onChange(field: keyof BoundingBox, value: number) {
 		// QA_AT-11: align with `GpsInput` and round to 6 decimals (~11 cm).
+		// QA_AT-24: NumericInput now string-truncates while typing (via
+		// maxDecimals={6} in renderInput). This toFixed(6) round remains as a
+		// defence-in-depth net for non-input paths — paste, programmatic
+		// bbox prefills from country / GPS centroid recompute, etc.
 		if (value) {
 			this.bBoxModel[field] = parseFloat(value.toFixed(6));
 		} else {
@@ -58,6 +62,7 @@ class GpsBoundingBoxInputComponent extends TsxComponent<GpsBoundingBoxInputArgs>
 					label={label}
 					value={value}
 					step={0.000001}
+					maxDecimals={6}
 					mode={NumericInputMode.Clasic}
 					showClearValueButton={showClearValueButton}
 					validationState={validationState}

package/components/input/gps-input.tsx

@@ -61,12 +61,17 @@ class GpsInputComponent extends TsxComponent<GpsInputArgs> implements GpsInputAr
 								label={null}
 								value={this.gpsModel.latitude}
 								step={0.000001}
+								maxDecimals={6}
 								mode={NumericInputMode.Clasic}
 								showClearValueButton={this.showClearValueButton}
 								validationState={this.validationStateLatitude}
 								disabled={this.disabled}
 								changed={(e) => {
 									if (e) {
+										// QA_AT-24: NumericInput now string-truncates while typing
+										// (via maxDecimals={6}). The toFixed(6) round here remains as
+										// a defence-in-depth net for non-input paths — map
+										// contextmenu click, programmatic centroid prefills, paste.
 										this.gpsModel.latitude = parseFloat(e.toFixed(6));
 									} else {
 										this.gpsModel.latitude = null;
@@ -81,12 +86,14 @@ class GpsInputComponent extends TsxComponent<GpsInputArgs> implements GpsInputAr
 								label={null}
 								value={this.gpsModel.longitude}
 								step={0.000001}
+								maxDecimals={6}
 								mode={NumericInputMode.Clasic}
 								showClearValueButton={this.showClearValueButton}
 								validationState={this.validationStateLongitude}
 								disabled={this.disabled}
 								changed={(e) => {
 									if (e) {
+										// QA_AT-24: see latitude comment — same defence-in-depth net.
 										this.gpsModel.longitude = parseFloat(e.toFixed(6));
 									} else {
 										this.gpsModel.longitude = null;

package/components/input/numeric-input.tsx

@@ -23,6 +23,26 @@ interface NumericInputArgs extends Omit<FormItemWrapperArgs, 'errorId'> {
 	updateMode?: 'input' | 'change';
 	placeholder?: string;
 	decimalsAlwaysVisible?: boolean;
+	/**
+	 * QA_AT-24: when set (Classic mode only), the input clamps the visible
+	 * value to at most this many decimal places AS THE USER TYPES — not only
+	 * on blur / save. Excess decimal characters are stripped via string
+	 * truncation (NOT numeric rounding) so digits the operator typed are
+	 * never silently rewritten; the DOM `input.value` is rewritten in place.
+	 * Intermediate states like `12.` are preserved so the operator can
+	 * continue typing.
+	 *
+	 * The `changed` callback respects `updateMode`: under the default
+	 * (change-on-blur) it is NOT fired per-keystroke even when truncation
+	 * happens — the trailing native `change` on blur reads the truncated DOM
+	 * value and propagates it. Callers that want per-keystroke updates must
+	 * opt in with `updateMode='input'`.
+	 *
+	 * Undefined = legacy unbounded-precision behaviour preserved for all
+	 * existing callers. Spinner mode ignores this prop (Spinner editor
+	 * already enforces decimals via Intl.NumberFormat on blur).
+	 */
+	maxDecimals?: number;
 	changed: (newValue: number) => void;
 	mode?: NumericInputMode;
 	disabled?: boolean;
@@ -52,6 +72,7 @@ class NumericInputComponent extends TsxComponent<NumericInputArgs> implements Nu
 	@Prop() appendClicked: () => void;
 	@Prop() prependClicked: () => void;
 	@Prop() decimalsAlwaysVisible!: boolean;
+	@Prop() maxDecimals?: number;
 	@Prop() mode: NumericInputMode;
 	@Prop() updateMode?: 'input' | 'change';
 	@Prop() disabled?: boolean;
@@ -92,6 +113,50 @@ class NumericInputComponent extends TsxComponent<NumericInputArgs> implements Nu
 		}
 	}
 
+	/**
+	 * QA_AT-24: when `maxDecimals` is set and the typed value carries more
+	 * decimal places than allowed, rewrite the DOM `input.value` to the
+	 * truncated representation. Returns the truncated numeric value, or
+	 * `null` when no truncation happened or the input is not yet a complete
+	 * number — e.g. the intermediate state `12.` keeps its trailing dot so
+	 * the operator can continue typing.
+	 *
+	 * Non-destructive for intermediate states: typing `12.` leaves `12.` in
+	 * the DOM; only EXCESS decimal characters past `maxDecimals` are
+	 * stripped. Uses string truncation (NOT numeric rounding) so digits the
+	 * operator already typed are never silently rewritten — the save-side
+	 * `parseFloat(e.toFixed(6))` in GpsInput / GpsBoundingBoxInput remains as
+	 * a defence-in-depth rounding net for non-input paths.
+	 */
+	private clampToMaxDecimals(inputEl: HTMLInputElement): number | null {
+		if (this.maxDecimals == null || this.maxDecimals < 0) {
+			return null;
+		}
+
+		const raw = inputEl.value;
+		if (raw == null || raw === '') {
+			return null;
+		}
+
+		// Preserve trailing "." and partial inputs like "12." — they have a
+		// length-0 decimal substring which is <= cap.
+		const dotIndex = raw.indexOf('.');
+		if (dotIndex < 0) {
+			return null;
+		}
+
+		const decimalPart = raw.slice(dotIndex + 1);
+		if (decimalPart.length <= this.maxDecimals) {
+			return null;
+		}
+
+		const truncatedString = raw.slice(0, dotIndex + 1 + this.maxDecimals);
+		inputEl.value = truncatedString;
+		const parsed = parseFloat(truncatedString);
+
+		return isNaN(parsed) ? null : parsed;
+	}
+
 	getMode(): NumericInputMode {
 		if (this.mode != null) {
 			return this.mode;
@@ -150,6 +215,22 @@ class NumericInputComponent extends TsxComponent<NumericInputArgs> implements Nu
 						value={inputValue}
 						onChange={e => this.raiseChangeEvent(e)}
 						onInput={(e) => {
+							// QA_AT-24: input-time decimal clamp. Always trims the DOM
+							// `input.value` when `maxDecimals` is exceeded so the operator
+							// never sees more digits than allowed; the `changed` callback
+							// however respects `updateMode` — under the default
+							// change-on-blur contract the trailing native `change` reads
+							// the truncated DOM value and propagates it, so we don't fire
+							// per-keystroke (which previously caused mid-typing reactive
+							// storms on `gpsModel.latitude` → map re-centering →
+							// validation re-runs).
+							if (this.maxDecimals != null && this.maxDecimals >= 0) {
+								const truncated = this.clampToMaxDecimals(e.target as HTMLInputElement);
+								if (truncated != null && this.changed != null && this.updateMode == 'input') {
+									this.changed(truncated);
+								}
+							}
+
 							if (this.updateMode == 'input') {
 								this.handleClassicInput(e);
 							}

package/components/open-street-map/open-street-map.tsx

@@ -1,3 +1,4 @@
+import type BoundingBox from '../../data/bounding-box';
 import { LGeoJson, LLayerGroup, LMap, LMarker, LPolygon, LTileLayer } from '@vue-leaflet/vue-leaflet';
 import L from 'leaflet';
 import * as LCluster from 'leaflet.markercluster';
@@ -5,7 +6,6 @@ import { Prop, toNative, Watch } from 'vue-facing-decorator';
 import TsxComponent, { Component } from '../../app/vuetsx';
 import { isNullOrEmpty } from '../../common/utils/is-null-or-empty';
 import { ModalUtils } from '../modal/modal-utils';
-import BoundingBox from '../../data/bounding-box';
 import iconUrl from './img/marker-icon.png';
 import GestureHandling from './ts/gesture-handling/gesture-handling';
 import 'leaflet/dist/leaflet.css';
@@ -77,7 +77,7 @@ interface OpenStreetMapArgs {
 }
 
 export class OpenStreetMapHelper {
-	static getMarkerIcon (): L.Icon<L.IconOptions> {
+	static getMarkerIcon(): L.Icon<L.IconOptions> {
 		return L.icon({
 			iconUrl,
 			iconAnchor: [
@@ -135,8 +135,21 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 	@Prop() initComplete?: (map: any, mapHandler: any) => void;
 	leafletIcon: any = null;
 	markerClusters: LCluster.MarkerClusterGroup = null;
-
-	mounted () {
+	/**
+	 * QA_AT-21: self-heal observer. Leaflet caches container size at mount
+	 * (`L.Map._size`); when the host element starts at 0×0 (hidden tab pane,
+	 * collapsed sidebar, dismissed modal, deferred reveal) only one tile in
+	 * the top-left renders and `containerPointToLatLng` returns drifted
+	 * coordinates for right-click pin moves. `ResizeObserver` fires once the
+	 * element gets its real size and recalls `invalidateSize()` — generic
+	 * mechanism that benefits every consumer (admin location/resort modals,
+	 * shop search-results-map-view, product-picker-dropdown-map, ...).
+	 */
+	private _resizeObserver: ResizeObserver | null = null;
+	private _lastObservedWidth: number = 0;
+	private _pendingResizeRaf: number | null = null;
+
+	mounted() {
 		this.initIcon();
 		this.waitForLeaflet().then(() => {
 			ModalUtils.handleModalMountDelay(this, () => {
@@ -149,21 +162,103 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 						this.initComplete(this.getLeaflet(), this.getMap());
 					});
 				}
+
+				// QA_AT-21: attach AFTER the initial invalidateSize so the
+				// first reading we cache reflects the real mounted size and
+				// the observer fires only on subsequent meaningful resizes.
+				this.attachResizeObserver();
+			});
+		});
+	}
+
+	beforeUnmount() {
+		// QA_AT-21: clean up the observer so detached components don't keep
+		// calling `invalidateSize()` on a torn-down map instance.
+		if (this._resizeObserver != null) {
+			this._resizeObserver.disconnect();
+			this._resizeObserver = null;
+		}
+
+		if (this._pendingResizeRaf != null && typeof (globalThis as any).cancelAnimationFrame === 'function') {
+			(globalThis as any).cancelAnimationFrame(this._pendingResizeRaf);
+			this._pendingResizeRaf = null;
+		}
+	}
+
+	private attachResizeObserver() {
+		const el = this.$el as HTMLElement | null;
+		if (el == null) {
+			return;
+		}
+
+		// Guard for SSR + jsdom (`ResizeObserver` only exists in real browsers;
+		// Chromium 64+ / Firefox 69+).
+		if (typeof globalThis === 'undefined' || typeof (globalThis as any).ResizeObserver !== 'function') {
+			return;
+		}
+
+		const RO = (globalThis as any).ResizeObserver as typeof ResizeObserver;
+		this._lastObservedWidth = el.getBoundingClientRect().width || 0;
+		this._resizeObserver = new RO((entries) => {
+			const entry = entries[0];
+			if (entry == null) {
+				return;
+			}
+
+			const width = entry.contentRect?.width ?? 0;
+			// Skip no-op resizes — `invalidateSize()` is cheap but schedules a
+			// re-render; gate on width-delta > 1 px to prevent feedback loops.
+			if (Math.abs(width - this._lastObservedWidth) < 1) {
+				return;
+			}
+
+			this._lastObservedWidth = width;
+			// Only run once the container has a real size so the meaningful
+			// first invalidate happens AFTER the container becomes visible.
+			if (width <= 0) {
+				return;
+			}
+
+			// QA_AT-21: rAF-coalesce rapid RO fires (window-resize drag,
+			// sidebar collapse animation, transition end chains) into one
+			// `invalidateSize()` per animation frame. Also defuses the
+			// browser "ResizeObserver loop completed with undelivered
+			// notifications" warning if Leaflet's redraw chains back into a
+			// sub-element size change. We use schedule-once-per-frame
+			// (skip-if-pending) rather than cancel-and-reschedule — the
+			// pending callback already reads current DOM state at fire time,
+			// so the latest size is picked up without re-arming.
+			const raf = (globalThis as any).requestAnimationFrame as ((cb: () => void) => number) | undefined;
+			if (typeof raf !== 'function') {
+				this.invalidateSize();
+				return;
+			}
+
+			if (this._pendingResizeRaf != null) {
+				return;
+			}
+
+			this._pendingResizeRaf = raf(() => {
+				this._pendingResizeRaf = null;
+				this.invalidateSize();
 			});
 		});
+		this._resizeObserver.observe(el);
 	}
 
 	@Watch('bBox', { immediate: false, deep: true })
-	onBoundingBoxChanged () {
+	onBoundingBoxChanged() {
 		const bounds = this.getBoundingBoxLatLngBounds();
 		if (bounds) {
 			this.getLeaflet()?.fitBounds(bounds);
 		}
 	}
 
-	async waitForLeaflet (timeout = 15000, interval = 100) {
+	async waitForLeaflet(timeout = 15000, interval = 100) {
+		// eslint-disable-next-line no-restricted-syntax
 		const startTime = Date.now();
 		while (!this.getLeaflet()) {
+			// eslint-disable-next-line no-restricted-syntax
 			if (Date.now() - startTime > timeout) {
 				console.error('Leaflet initialization timed out.');
 				return null; // or throw an error, depending on your needs
@@ -174,27 +269,27 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 		return this.getLeaflet();
 	}
 
-	initIcon () {
+	initIcon() {
 		if (this.leafletIcon == null) {
 			this.leafletIcon = OpenStreetMapHelper.getMarkerIcon();
 		}
 	}
 
 	@Watch('geoJSON')
-	onGeoJsonChanged () {
+	onGeoJsonChanged() {
 		if (this.geoJSONClustering) {
 			this.waitForLeaflet().then(() => {
-				this.initCluster()
-			})
+				this.initCluster();
+			});
 		}
 	}
 
 	@Watch('mapUrl')
-	onMapUrlChanged () {
+	onMapUrlChanged() {
 		this.invalidateSize();
 	}
 
-	initGestureHandling () {
+	initGestureHandling() {
 		if (this.gestureHandling == true) {
 			const leaflet = this.getLeaflet();
 			if ((leaflet as any)._gesturesBinder != true) {
@@ -204,10 +299,10 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 		}
 	}
 
-	initCluster () {
+	initCluster() {
 		this.markerClusters?.clearLayers();
 		this.markerClusters = new LCluster.MarkerClusterGroup(this.clusterOptions || {
-			iconCreateFunction (cluster) {
+			iconCreateFunction(cluster) {
 				const html = `<div class="cluster-marker ">${cluster.getChildCount()}<div class="pulse-animation"></div></div>`;
 				return L.divIcon({ html, className: 'cluster-icon' });
 			},
@@ -225,7 +320,7 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 		}
 	}
 
-	invalidateSize () {
+	invalidateSize() {
 		const leaflet = this.getLeaflet();
 		if (leaflet != null) {
 			this.$nextTick(() => {
@@ -234,11 +329,11 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 		}
 	}
 
-	getNumeric (val: string): number {
+	getNumeric(val: string): number {
 		return Number((val || '').toString().split(',').join(''));
 	}
 
-	getZoomValue (): number {
+	getZoomValue(): number {
 		if (this.defaultZoom != null) {
 			return this.defaultZoom;
 		} else if (this.bBox != null) {
@@ -248,60 +343,71 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 		}
 	}
 
-	getCenter () {
+	getCenter() {
 		if (this.bBox != null) {
 			const { x1, x2, y1, y2 } = this.bBox;
 			const lat = (y1 + y2) / 2;
 			const lng = (x1 + x2) / 2;
-			return [lat, lng];
+			return [
+				lat,
+				lng,
+			];
 		}
 
 		const locArr = this.getLocArr();
 		return locArr;
 	}
 
-	getLocPoint () {
+	getLocPoint() {
 		return {
 			lat: this.getNumeric(this.latitude),
 			lng: this.getNumeric(this.longitude),
 		};
 	}
 
-	getLocArr () {
+	getLocArr() {
 		return [
 			this.getNumeric(this.latitude),
 			this.getNumeric(this.longitude),
 		];
 	}
 
-	getMap () {
+	getMap() {
 		return this.$refs.mainMap;
 	}
 
-	getTileLayerOptions () {
+	getTileLayerOptions() {
 		const options = { ...(this.options || {}) } as any;
 		if (typeof URL !== 'undefined' && typeof URL.canParse === 'function' && URL.canParse(this.mapUrl)) {
 			const urlHostname = new URL(this.mapUrl).hostname;
-			const osmHosts = ['tile.openstreetmap.org', 'tile.osm.org'];
+			const osmHosts = [
+				'tile.openstreetmap.org',
+				'tile.osm.org',
+			];
 			if (osmHosts.some(host => urlHostname.endsWith(host)) && options.referrerPolicy == null) {
 				options.referrerPolicy = 'strict-origin-when-cross-origin';
 			}
 		}
-		
+
 		return options;
 	}
 
-	getLeaflet () {
+	getLeaflet() {
 		return (this.getMap() as any)?.leafletObject;
 	}
 
-	getBoundingBoxCorners () {
+	getBoundingBoxCorners() {
 		if (!this.bBox) {
 			return [];
 		}
 
 		const { x1, x2, y1, y2 } = this.bBox;
-		if ([x1, x2, y1, y2].some(p => p == null)) {
+		if ([
+			x1,
+			x2,
+			y1,
+			y2,
+		].some(p => p == null)) {
 			return [];
 		}
 
@@ -311,15 +417,30 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 		const maxLng = Math.max(x1, x2);
 
 		return [
-			[maxLat, minLng],
-			[maxLat, maxLng],
-			[minLat, maxLng],
-			[minLat, minLng],
-			[maxLat, minLng],
+			[
+				maxLat,
+				minLng,
+			],
+			[
+				maxLat,
+				maxLng,
+			],
+			[
+				minLat,
+				maxLng,
+			],
+			[
+				minLat,
+				minLng,
+			],
+			[
+				maxLat,
+				minLng,
+			],
 		];
 	}
 
-	getBoundingBoxLatLngBounds (): L.LatLngBounds {
+	getBoundingBoxLatLngBounds(): L.LatLngBounds {
 		const corners = this.getBoundingBoxCorners();
 		if (corners.length < 2) {
 			return null;
@@ -328,7 +449,7 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 		return L.latLngBounds(corners);
 	}
 
-	render (h) {
+	render(h) {
 		if (this.is16by9 == false) {
 			return this.renderLeaflet(h, { height: '100%' });
 		}
@@ -346,17 +467,17 @@ export class OpenStreetMapComponent extends TsxComponent<OpenStreetMapArgs> impl
 		);
 	}
 
-	private renderLeaflet (h, style: object) {
+	private renderLeaflet(h, style: object) {
 		const locArr = this.getLocArr();
 
 		return (
 			<l-map style={style} zoom={this.getZoomValue()} options={this.mapOptions} maxZoom={this.maxZoom} center={this.getCenter()} ref="mainMap">
 				<l-tile-layer url={this.mapUrl} options={this.getTileLayerOptions()} noWrap attribution={'&copy; <a target="_blank" href="http://osm.org/copyright">OpenStreetMap</a> contributors'}></l-tile-layer>
 				{!this.isCenterHidden
-					&& <l-marker lat-lng={locArr} icon={this.leafletIcon}></l-marker>}
+				&& <l-marker lat-lng={locArr} icon={this.leafletIcon}></l-marker>}
 
 				{!isNullOrEmpty(this.geoJSON)
-					&& <l-geo-json ref="geoJson" options={this.geoJSONConfig != null && this.geoJSONConfig} geojson={this.geoJSONClustering ? [] : this.geoJSON}></l-geo-json>}
+				&& <l-geo-json ref="geoJson" options={this.geoJSONConfig != null && this.geoJSONConfig} geojson={this.geoJSONClustering ? [] : this.geoJSON}></l-geo-json>}
 
 				{this.bBox && (
 					<l-polygon

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "inviton-powerduck",
 	"type": "module",
-	"version": "0.0.331",
+	"version": "0.0.332",
 	"files": [
 		"app/",
 		"common/",