@feedmepos/mf-menu 0.32.66-dev.2 → 0.32.66-dev.3

package/dist/{app-DwyLCetV.js → app-Du5OtlE9.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-CESDAztS.js";
+import { J as a, K as s, L as l } from "./index.vue_vue_type_script_setup_true_lang-Cf2AKbC7.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-Cbzk6cOz.js";
+import { F as e, i as r, j as o, o as t, r as i, u as p } from "./app-BGCDoU-0.js";
 export {
   e as FmApp,
   r as i18nMessages,

package/dist/apps/mf-menu/src/api/media.d.ts

@@ -14,6 +14,15 @@ export declare function normalizeMediaRefId(refId: string): string;
 export type AspectRatio = string;
 /** Ratios every product image is expected to carry; they cannot be removed in the UI. */
 export declare const REQUIRED_ASPECT_RATIOS: AspectRatio[];
+/**
+ * Reserved ratio word for the uploaded image itself (backend `model.RatioOriginal`).
+ *
+ * Not a generatable ratio: `/images/create` rejects it, and on `/images/update` it
+ * selects the write-the-original mode rather than naming a variant. Kept as a constant
+ * because `AspectRatio` is a bare string — the type cannot keep the two apart, so the
+ * distinction has to be visible at the call site.
+ */
+export declare const RATIO_ORIGINAL = "original";
 export type VariantStatus = "pending" | "active" | "failed";
 export interface MediaVariant {
     aspectRatio: AspectRatio;
@@ -106,18 +115,23 @@ export declare const mediaService: {
         mode: "append" | "replace";
     }): Promise<CreateRes>;
     /**
-     * Rewrites exactly one aspect ratio. Every other ratio and the original are left
-     * alone — `original` itself is rejected with 400, it is immutable for its lifetime,
-     * which is what keeps a stored thumbnail URL stable.
+     * Regenerates exactly one aspect ratio, leaving every other ratio and the original
+     * alone. For rewriting the original itself, see `updateOriginal` — same endpoint,
+     * different mode, and the only one that is not AI generation.
      *
-     * Which of the two modes runs is decided by the field that is filled:
-     * - `base64` overwrites the variant with the merchant's own bytes, synchronously
-     * - `instruction` queues an AI re-edit, so the ratio drops back to `pending`
-     *   (with `regenerateFromOrigin`, it re-derives from the original instead of the
-     *   current variant, discarding previous variant edits)
+     * Both modes here are AI generation, and which one runs is decided by the field that
+     * is filled (either, or both):
+     * - `base64` stores the supplied bytes as the *source* and queues generation from
+     *   them. It is not a passthrough: the service trims uniform bars off the source and
+     *   hands it to the model, so what lands is a redraw of the merchant's image at this
+     *   ratio, not the merchant's image. Changed by media-service `db04d1f`; before that
+     *   it was a synchronous byte write, which is what this client used to document.
+     * - `instruction` queues a re-edit of the variant's *current* image (with
+     *   `regenerateFromOrigin`, of the original instead, discarding previous edits).
      *
-     * Callers must send exactly one of `base64` or `instruction`; the service rejects an
-     * update request that contains neither with `400 INVALID_PARAM`.
+     * Either way the ratio drops back to `pending` for ~40s and the request consumes one
+     * AI generation from the business's license allowance. The service rejects an update
+     * carrying neither field with `400 INVALID_PARAM`.
      *
      * Unlike an upload these bytes do pass through the service pod — there is no
      * variant-level `upload-intent` — so callers must send a cropped, re-encoded image
@@ -139,6 +153,45 @@ export declare const mediaService: {
          */
         regenerateFromOrigin?: boolean;
     }): Promise<void>;
+    /**
+     * Rewrites the uploaded original in place, synchronously (media-service `a0cc055`).
+     *
+     * The one mode of `/images/update` that is not AI: the bytes are stored as-is and
+     * nothing is queued, so no generation is billed. Sending `instruction`, `params` or
+     * `regenerateFromOrigin` alongside `aspectRatio: "original"` is a `400 INVALID_PARAM`
+     * — hence a separate method rather than a flag on `update`, so the invalid combination
+     * cannot be expressed here at all.
+     *
+     * `base64` may be a data URL or bare base64; the stored Content-Type is sniffed from
+     * the bytes rather than read off the data URL. The service re-reads `width`, `height`,
+     * `mimeType` and `fileSize` from them — `fileName` is deliberately left as it was.
+     * Limits are the upload's: 10 MiB decoded (`413 PAYLOAD_TOO_LARGE`, checked on the
+     * encoded length too), jpeg/png/webp only (`415 UNSUPPORTED_MEDIA_TYPE`).
+     *
+     * Two things the caller owns afterwards:
+     * - **Stale variants.** Existing ratios are retained and are *not* regenerated, so
+     *   they still derive from the photo that was just replaced. Requeue the ones that
+     *   should follow the original with `create({ mode: "append" })` — `generateAspectRatios`
+     *   with `includeExisting` — skipping any ratio whose `imageSet` value is set, since
+     *   that marks a photo the merchant supplied and must never be regenerated out from
+     *   under them. It has to be `append`: `replace` also *deletes* every variant absent
+     *   from the request, so requeueing a subset with it would take the merchant's own
+     *   ratios down with it.
+     * - **Caches.** The URL does not change, which is the point: nothing in the menu
+     *   document has to be written. The service purges the original URL from the edge, but
+     *   that is fire-and-forget (and a no-op without Cloudflare credentials) and cannot
+     *   reach a browser that already fetched it, so surfaces showing the image must bust
+     *   their own cache with a `?t=` stamp. Safe to add: image-router only rewrites a
+     *   request that carries `aspect_ratio`. Never persist the stamped URL.
+     *
+     * The response is dropped for the same reason as `update`'s, and because it carries
+     * nothing new: the URL is unchanged and the status is always `active`.
+     */
+    updateOriginal(req: {
+        refId: string;
+        imageId: string;
+        base64: string;
+    }): Promise<void>;
     listImages(refIds: string[]): Promise<MediaImage[]>;
     getGenerationTask(taskId: string): Promise<GenerationTask>;
     delete(entries: DeleteEntry[]): Promise<void>;

package/dist/apps/mf-menu/src/app.d.ts

@@ -1966,6 +1966,29 @@ export declare const i18nMessages: {
             };
             product_image: {
                 hint: string;
+                crop_hint: string;
+                editor: {
+                    title: string;
+                    subtitle_upload: string;
+                    subtitle_counter: string;
+                    subtitle_edit: string;
+                    upload_rest: string;
+                    ratio: string;
+                    ratio_free: string;
+                    zoom: string;
+                    rotate: string;
+                    reset: string;
+                    output_original: string;
+                    output_edited: string;
+                    oversized: string;
+                    edit_notice_title: string;
+                    edit_notice_body: string;
+                    replace_notice_title: string;
+                    replace_notice_body: string;
+                    saving: string;
+                    saved: string;
+                    formats_failed: string;
+                };
                 drop_hint: string;
                 add_file: string;
                 cover_badge: string;
@@ -2021,11 +2044,10 @@ export declare const i18nMessages: {
                 replace: {
                     title: string;
                     action: string;
-                    unavailable: string;
                     hint: string;
                     accepts: string;
                     no_file: string;
-                    done: string;
+                    queued: string;
                 };
                 regenerate: {
                     title: string;
@@ -4000,6 +4022,29 @@ export declare const i18nMessages: {
             };
             product_image: {
                 hint: string;
+                crop_hint: string;
+                editor: {
+                    title: string;
+                    subtitle_upload: string;
+                    subtitle_counter: string;
+                    subtitle_edit: string;
+                    upload_rest: string;
+                    ratio: string;
+                    ratio_free: string;
+                    zoom: string;
+                    rotate: string;
+                    reset: string;
+                    output_original: string;
+                    output_edited: string;
+                    oversized: string;
+                    edit_notice_title: string;
+                    edit_notice_body: string;
+                    replace_notice_title: string;
+                    replace_notice_body: string;
+                    saving: string;
+                    saved: string;
+                    formats_failed: string;
+                };
                 drop_hint: string;
                 add_file: string;
                 cover_badge: string;
@@ -4055,11 +4100,10 @@ export declare const i18nMessages: {
                 replace: {
                     title: string;
                     action: string;
-                    unavailable: string;
                     hint: string;
                     accepts: string;
                     no_file: string;
-                    done: string;
+                    queued: string;
                 };
                 regenerate: {
                     title: string;
@@ -6035,6 +6079,29 @@ export declare const i18nMessages: {
             };
             product_image: {
                 hint: string;
+                crop_hint: string;
+                editor: {
+                    title: string;
+                    subtitle_upload: string;
+                    subtitle_counter: string;
+                    subtitle_edit: string;
+                    upload_rest: string;
+                    ratio: string;
+                    ratio_free: string;
+                    zoom: string;
+                    rotate: string;
+                    reset: string;
+                    output_original: string;
+                    output_edited: string;
+                    oversized: string;
+                    edit_notice_title: string;
+                    edit_notice_body: string;
+                    replace_notice_title: string;
+                    replace_notice_body: string;
+                    saving: string;
+                    saved: string;
+                    formats_failed: string;
+                };
                 drop_hint: string;
                 add_file: string;
                 cover_badge: string;
@@ -6090,11 +6157,10 @@ export declare const i18nMessages: {
                 replace: {
                     title: string;
                     action: string;
-                    unavailable: string;
                     hint: string;
                     accepts: string;
                     no_file: string;
-                    done: string;
+                    queued: string;
                 };
                 regenerate: {
                     title: string;
@@ -8069,6 +8135,29 @@ export declare const i18nMessages: {
             };
             product_image: {
                 hint: string;
+                crop_hint: string;
+                editor: {
+                    title: string;
+                    subtitle_upload: string;
+                    subtitle_counter: string;
+                    subtitle_edit: string;
+                    upload_rest: string;
+                    ratio: string;
+                    ratio_free: string;
+                    zoom: string;
+                    rotate: string;
+                    reset: string;
+                    output_original: string;
+                    output_edited: string;
+                    oversized: string;
+                    edit_notice_title: string;
+                    edit_notice_body: string;
+                    replace_notice_title: string;
+                    replace_notice_body: string;
+                    saving: string;
+                    saved: string;
+                    formats_failed: string;
+                };
                 drop_hint: string;
                 add_file: string;
                 cover_badge: string;
@@ -8124,11 +8213,10 @@ export declare const i18nMessages: {
                 replace: {
                     title: string;
                     action: string;
-                    unavailable: string;
                     hint: string;
                     accepts: string;
                     no_file: string;
-                    done: string;
+                    queued: string;
                 };
                 regenerate: {
                     title: string;
@@ -10092,6 +10180,29 @@ export declare const i18nMessages: {
             };
             product_image: {
                 hint: string;
+                crop_hint: string;
+                editor: {
+                    title: string;
+                    subtitle_upload: string;
+                    subtitle_counter: string;
+                    subtitle_edit: string;
+                    upload_rest: string;
+                    ratio: string;
+                    ratio_free: string;
+                    zoom: string;
+                    rotate: string;
+                    reset: string;
+                    output_original: string;
+                    output_edited: string;
+                    oversized: string;
+                    edit_notice_title: string;
+                    edit_notice_body: string;
+                    replace_notice_title: string;
+                    replace_notice_body: string;
+                    saving: string;
+                    saved: string;
+                    formats_failed: string;
+                };
                 drop_hint: string;
                 add_file: string;
                 cover_badge: string;
@@ -10147,11 +10258,10 @@ export declare const i18nMessages: {
                 replace: {
                     title: string;
                     action: string;
-                    unavailable: string;
                     hint: string;
                     accepts: string;
                     no_file: string;
-                    done: string;
+                    queued: string;
                 };
                 regenerate: {
                     title: string;

package/dist/apps/mf-menu/src/components/feature/Fields/RangeSlider.vue.d.ts

@@ -0,0 +1,62 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    modelValue: number;
+    min?: number | undefined;
+    max?: number | undefined;
+    step?: number | undefined;
+    disabled?: boolean | undefined;
+    ariaLabel?: string | undefined;
+    /** Renders the bubble shown while dragging; no bubble when omitted. */
+    formatValue?: ((value: number) => string) | undefined;
+}>, {
+    min: number;
+    max: number;
+    step: number;
+    disabled: boolean;
+    ariaLabel: undefined;
+    formatValue: undefined;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    modelValue: number;
+    min?: number | undefined;
+    max?: number | undefined;
+    step?: number | undefined;
+    disabled?: boolean | undefined;
+    ariaLabel?: string | undefined;
+    /** Renders the bubble shown while dragging; no bubble when omitted. */
+    formatValue?: ((value: number) => string) | undefined;
+}>, {
+    min: number;
+    max: number;
+    step: number;
+    disabled: boolean;
+    ariaLabel: undefined;
+    formatValue: undefined;
+}>>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    max: number;
+    min: number;
+    step: number;
+    ariaLabel: string;
+    formatValue: (value: number) => string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -43,6 +43,52 @@ export declare function generateImageId(): string;
  */
 export declare function autoAspectRatios(autoGenerate: boolean): AspectRatio[];
 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.
+ */
+export declare function validateImageType(file: File): string | null;
+/**
+ * Longest edge the editor writes out.
+ *
+ * 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.
+ */
+export declare const MAX_IMAGE_EDGE = 2400;
+/**
+ * Encodes an edited canvas as a file guaranteed to be uploadable.
+ *
+ * "Guaranteed" is the job: `upload-intent` rejects anything over `MAX_IMAGE_BYTES` with a
+ * 413 and `updateOriginal` does the same on the encoded length, so the editor must not be
+ * able to hand back a file the service will refuse — that would put the merchant back at
+ * the dead end this feature exists to remove. Quality is spent first and pixels second,
+ * because a slightly softer photo beats a smaller one.
+ *
+ * PNG is kept only when the caller asks for it (a source with transparency); it has no
+ * quality lever, so it is shrunk by size alone.
+ */
+export declare function canvasToFile(canvas: HTMLCanvasElement, options: {
+    fileName: string;
+    mime: string;
+    maxEdge?: number;
+    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.
+ *
+ * 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.
+ */
+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. */
@@ -72,6 +118,34 @@ export declare function uploadProductImage(itemId: string, file: File, options:
     imageId?: string;
     unreadableMessage?: string;
 }): Promise<FdoMenuV4ItemImage>;
+/**
+ * Rewrites an existing image's original bytes, keeping its identity.
+ *
+ * This is what makes editing an uploaded photo cheap: `updateOriginal` overwrites the
+ * object in place, so `_id`, `url`, `isDefault`, `imageSet` and the item's dual-written
+ * `thumbnail` all stay as they are and the menu document needs no write at all. The
+ * returned image is the one that was passed in, unchanged — callers persist nothing.
+ *
+ * What does need doing is the ratios. media-service deliberately leaves them alone, so
+ * every ratio derived from the old photo is now stale and has to be queued again from the
+ * new one. Only the derived ones: a ratio whose `imageSet` value is set is a photo the
+ * merchant supplied for that shape, and re-deriving it would throw their work away. The
+ * requeue is `append` (via `generateAspectRatios`), never `create({ mode: "replace" })` —
+ * replace also deletes every variant missing from the request, which for a subset means
+ * deleting exactly the merchant's own ratios.
+ *
+ * `formatsRequeued` is reported rather than thrown: by the time a requeue can fail the
+ * original is already overwritten, and a rejected promise would tell the merchant their
+ * crop failed when it did not. They need to hear that the photo is saved and its formats
+ * are not, which only the caller can phrase.
+ *
+ * The caller must bump the image's cache stamp (`bumpImageVersion`) — the URL did not
+ * move, so nothing refetches on its own.
+ */
+export declare function updateProductImageOriginal(itemId: string, image: FdoMenuV4ItemImage, file: File): Promise<{
+    image: FdoMenuV4ItemImage;
+    formatsRequeued: boolean;
+}>;
 /**
  * A file the merchant picked before the item it belongs to exists.
  *
@@ -116,21 +190,30 @@ export declare function generateAspectRatios(itemId: string, image: FdoMenuV4Ite
 /** `/images/update` carries its bytes inline, so the file has to become a data URL. */
 export declare function readFileAsDataUrl(file: File): Promise<string>;
 /**
- * Substitutes the merchant's own photo for one generated ratio and marks it custom.
+ * Queues one ratio to be generated from a photo the merchant supplies, and marks it
+ * custom.
+ *
+ * Named "replace" after what it does for the merchant, not after what reaches storage:
+ * media-service stores these bytes as the generation *source* and hands them to the
+ * model (`/images/update` with `base64`), so the variant ends up a redraw of the
+ * supplied photo rather than the photo itself. Cropping to `ratio` in the editor is what
+ * frames the subject for the model. It no longer pads the source to the ratio first: the
+ * service trims uniform bars off a generation source, so the bars were discarded before
+ * the model ever saw them — a real crop at least lets the merchant choose what survives.
  *
- * The variant keeps its URL and only the bytes behind it are rewritten, so the only
- * difference between the input image and the returned one is `imageSet[ratio]`: it
- * now carries the variant URL as a marker meaning "not derived from the original".
- * That URL is the same `{url}?aspect_ratio={ratio}` the consumer would compose
- * anyway — the value exists to be checked for null, not to point somewhere else. The
- * caller persists the returned image to save the marker.
+ * So this is asynchronous and billable, exactly like `regenerateAspectRatio`: the ratio
+ * drops back to `pending` for ~40s and one AI generation is consumed. Callers must show
+ * the ratio as generating and poll `listImages` — treating the returned image as final
+ * shows the merchant the old variant and calls it done.
  *
- * The caller also has to bust its own image cache — the URL is "always latest" at the
- * edge, but a browser that already fetched it will not know.
+ * The variant keeps its URL, so the only difference between the input image and the
+ * returned one is `imageSet[ratio]`: it now carries the variant URL as a marker meaning
+ * "not derived from the original". That URL is the same `{url}?aspect_ratio={ratio}` the
+ * consumer would compose anyway — the value exists to be checked for null, not to point
+ * somewhere else. The caller persists the returned image to save the marker.
  *
- * The file is expected to be cropped to `ratio` and re-encoded by the dialog: these
- * bytes travel through the service pod (no variant-level upload-intent exists), and a
- * variant is supposed to be exactly its ratio.
+ * The caller also has to bust its own image cache once the generation lands — the URL is
+ * "always latest" at the edge, but a browser that already fetched it will not know.
  */
 export declare function replaceAspectRatioImage(itemId: string, image: FdoMenuV4ItemImage, ratio: AspectRatio, file: File): Promise<FdoMenuV4ItemImage>;
 /**

package/dist/apps/mf-menu/src/components/feature/TreeEditor/image/ImageEditorDialog.vue.d.ts

@@ -0,0 +1,56 @@
+import "vue-advanced-cropper/dist/style.css";
+/**
+ * What the dialog hands back: a thunk, not a file.
+ *
+ * Encoding a crop costs a full canvas re-encode, and the cropper emits `change` on every
+ * drag frame — emitting a File each time would re-encode a 12 MP photo dozens of times
+ * per gesture. So the parent gets a function and calls it once, on confirm.
+ */
+export type ProduceEditedImage = () => Promise<File | null>;
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    mode: "upload" | "edit" | "replace";
+    /** Absent in `replace`, where the merchant picks the photo inside the dialog. */
+    file?: File | null | undefined;
+    /** Locks the crop shape. Only `replace` sets it. */
+    ratio?: string | null | undefined;
+    /** How many generated formats a save will re-derive; drives the `edit` notice. */
+    derivedFormats?: number | undefined;
+}>, {
+    file: null;
+    ratio: null;
+    derivedFormats: number;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    mode: "upload" | "edit" | "replace";
+    /** Absent in `replace`, where the merchant picks the photo inside the dialog. */
+    file?: File | null | undefined;
+    /** Locks the crop shape. Only `replace` sets it. */
+    ratio?: string | null | undefined;
+    /** How many generated formats a save will re-derive; drives the `edit` notice. */
+    derivedFormats?: number | undefined;
+}>, {
+    file: null;
+    ratio: null;
+    derivedFormats: number;
+}>>> & Readonly<{}>, {
+    ratio: string | null;
+    file: File | null;
+    derivedFormats: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/apps/mf-menu/src/composable/imageSource.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The original behind `url` as a `File`, from memory when it has been read before.
+ *
+ * Returns null when it cannot be read, exactly like `fetchImageAsBlob` — a failure is
+ * never remembered, so the next click is free to try again.
+ */
+export declare function readImageFile(url: string, imageId: string, filename?: string): Promise<File | null>;

package/dist/apps/mf-menu/src/composable/imageVersion.d.ts

@@ -0,0 +1,11 @@
+/** Call after the bytes behind `imageId` have been rewritten. */
+export declare function bumpImageVersion(imageId: string): void;
+/**
+ * Appends the current stamp for `imageId`, if it has one.
+ *
+ * Untouched images are returned as-is rather than stamped with a constant: the URL is a
+ * cache key, and a first render that already differs from what POS requests would throw
+ * away a warm edge entry for nothing.
+ */
+export declare function stampImageUrl(url: string, imageId: string): string;
+export declare function stampImageUrl(url: string | null | undefined, imageId: string): string | null | undefined;

package/dist/apps/mf-menu/src/helper/itemOverrider.d.ts

@@ -0,0 +1,10 @@
+import type { FdoItemOverriderV4 } from "@feedmepos/entity";
+/**
+ * Pick an item's base (non-variant) overrider out of an overrider list.
+ *
+ * Catalog/scheduler overrider maps only hold entries for items that were
+ * actually overridden, so the list is often absent entirely. When it exists it
+ * is ordered `[...variantCombinations, baseOverrider]`, so index 0 is not the
+ * base overrider once the item has variants.
+ */
+export declare function pickBaseOverrider(overriders: FdoItemOverriderV4[] | undefined | null): FdoItemOverriderV4 | undefined;