@feedmepos/mf-menu 0.32.70 → 0.32.71

package/dist/{app-qoGPYaSq.js → app-CMjz-bvL.js}

@@ -1,5 +1,5 @@
 import { defineStore as r } from "pinia";
-import { J as a, K as s, L as l } from "./index.vue_vue_type_script_setup_true_lang-Wm3L_CDm.js";
+import { J as a, K as s, L as l } from "./index.vue_vue_type_script_setup_true_lang-BCZZq6zJ.js";
 const u = {
   async read() {
     return a(await s().get("/public-setting"));

package/dist/app.js

@@ -1,4 +1,4 @@
-import { F as e, i as r, j as o, o as t, r as i, u as p } from "./app-DDrm4hOt.js";
+import { F as e, i as r, j as o, o as t, r as i, u as p } from "./app-2VeaJE9t.js";
 export {
   e as FmApp,
   r as i18nMessages,

package/dist/apps/mf-menu/src/components/feature/TreeEditor/composable/productImages.d.ts

@@ -47,20 +47,22 @@ export declare function validateImageFile(file: File): string | null;
  * The half of `validateImageFile` that is a real dead end.
  *
  * A file the browser cannot decode is refused outright, but being over
- * `MAX_IMAGE_BYTES` is not a reason to refuse a photo any more: the editor re-encodes it
- * under the limit (`canvasToFile`), which is the whole point of opening on upload. Call
- * sites that hand bytes straight to media-service — Remy's output, a staged flush —
- * still use the combined check, because nothing there can shrink a file.
+ * `MAX_IMAGE_BYTES` is not a reason to refuse a photo any more: every upload is re-encoded
+ * under the limit (`compressImageForUpload`), which is the whole point of opening on
+ * upload. The combined check is left for the base64 payload handed *to* Remy, which
+ * nothing shrinks on the way in.
  */
 export declare function validateImageType(file: File): string | null;
 /**
- * Longest edge the editor writes out.
+ * Longest edge an upload is allowed to keep.
  *
- * Generous — media-service derives every ratio from this original, and 2400px still
- * covers a retina hero on the biggest POS screen — but bounded, so a 48MP phone photo
- * cannot land as a 20 MB original that has to be re-encoded on every later edit.
+ * Every picked file is re-encoded to fit this box (`compressImageForUpload`), so it is
+ * the effective ceiling on what reaches media-service rather than just a cap the editor
+ * happens to respect. 2000px still covers a retina hero on the biggest POS screen, and
+ * it is what the pre-multi-image thumbnail flow wrote out, so nothing regresses against
+ * the images already in the wild.
  */
-export declare const MAX_IMAGE_EDGE = 2400;
+export declare const MAX_IMAGE_EDGE = 2000;
 /**
  * Encodes an edited canvas as a file guaranteed to be uploadable.
  *
@@ -80,16 +82,26 @@ export declare function canvasToFile(canvas: HTMLCanvasElement, options: {
     maxBytes?: number;
 }): Promise<File>;
 /**
- * Hands back the file untouched when it already fits `MAX_IMAGE_BYTES`, and otherwise
- * re-encodes it under the limit exactly as the editor would — same edge cap, same
- * PNG-stays-PNG rule.
+ * Re-encodes a picked file to `MAX_IMAGE_EDGE` / `OUTPUT_QUALITY` before it is uploaded.
  *
- * This is for the paths that upload a picked file without opening the editor (the
- * "upload the rest as-is" batch): they get the same guarantee a confirmed edit has,
- * instead of handing media-service bytes it will refuse with a 413.
+ * Unconditional by design. The single-thumbnail flow this feature replaced compressed
+ * every image on the way out (4:3, 2000px, JPEG q0.75); the multi-image rewrite dropped
+ * that for a plain size check, which let a full-resolution phone photo reach
+ * media-service verbatim as long as it happened to sit under `MAX_IMAGE_BYTES`. So the
+ * trigger is the edge cap now, not the byte limit — an 8 MB 12MP original is compressed
+ * exactly like a 12 MB one.
+ *
+ * The one file handed back untouched is the one re-encoding would only make worse: canvas
+ * has no quality lever for PNG and re-encodes an already-optimised one bigger, and a JPEG
+ * already saved below `OUTPUT_QUALITY` grows too. When the source is inside the edge cap, already
+ * uploadable, in the very format the encoder would have written, and smaller than what
+ * came back, the original wins — "compressed" has to mean smaller.
+ */
+export declare function compressImageForUpload(file: File, unreadableMessage?: string): Promise<File>;
+/**
+ * Converts Remy's base64 result into a File. It is not compressed here — the caller runs
+ * it through `compressImageForUpload` like any other upload.
  */
-export declare function ensureUploadableImage(file: File, unreadableMessage?: string): Promise<File>;
-/** Converts Remy's base64 result into an uploadable file without re-encoding it. */
 export declare function dataUrlToFile(dataUrl: string, fileName?: string): Promise<File>;
 /** `confirm` needs the real pixel size, and only the browser has it before upload. */
 export declare function readImageDimensions(file: File, unreadableMessage?: string): Promise<{