feat(ui): one delivery select for fonts and graphics, derived from design and profile

Author: u8array

packages/core/src/lib/resourceDelivery.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { applyFontDelivery, applyGraphicDelivery, fontDelivery, graphicDelivery, graphicJobShips } from "./resourceDelivery";
+import type { ImageProps } from "../registry/image";
+
+const GFA = "^GFA,4,4,1,00FFFF00";
+const image = (extra: Partial<ImageProps["storedAs"]> | null = {}): ImageProps => ({
+  imageId: "",
+  widthDots: 8,
+  heightDots: 4,
+  threshold: 128,
+  _gfaCache: GFA,
+  ...(extra === null ? {} : { storedAs: { device: "R", name: "LOGO", ...extra } }),
+});
+const entry = { path: "R:LOGO.GRF", gfa: GFA };
+const recallOnly = { device: "R", name: "LOGO", embedInZpl: false };
+
+describe("fontDelivery", () => {
+  it("reads job while the design ships the font, even with a profile entry beside it", () => {
+    expect(fontDelivery({ embedInZpl: true }, "E:A.TTF", [{ path: "E:A.TTF" }])).toBe("job");
+    expect(fontDelivery({ embedInZpl: true }, "E:A.TTF", undefined)).toBe("job");
+  });
+
+  it("reads setup from the profile entry under any spelling, else printer", () => {
+    expect(fontDelivery(undefined, "E:A.TTF", [{ path: "e:a.ttf" }])).toBe("setup");
+    expect(fontDelivery({ embedInZpl: undefined }, "E:A.TTF", undefined)).toBe("printer");
+  });
+
+  it("keeps the profile entry when the job takes over, and drops it only for printer", () => {
+    const setup = [{ path: "E:A.TTF" }];
+    expect(applyFontDelivery("job", undefined, "E:A.TTF", setup)).toEqual({ patch: { embedInZpl: true }, setupFonts: setup });
+    expect(applyFontDelivery("setup", { embedInZpl: true }, "E:A.TTF", undefined)).toEqual({ patch: { embedInZpl: undefined }, setupFonts: [{ path: "E:A.TTF" }] });
+    expect(applyFontDelivery("printer", undefined, "E:A.TTF", setup)).toEqual({ patch: null, setupFonts: undefined });
+  });
+
+  it("writes nothing the design or profile already holds", () => {
+    const setup = [{ path: "E:A.TTF" }];
+    expect(applyFontDelivery("job", { embedInZpl: true }, "E:A.TTF", setup)).toEqual({ patch: null, setupFonts: setup });
+    expect(applyFontDelivery("setup", undefined, "E:A.TTF", setup).setupFonts).toBe(setup);
+    const other = [{ path: "E:B.TTF" }];
+    expect(applyFontDelivery("printer", undefined, "E:A.TTF", other)).toEqual({ patch: null, setupFonts: other });
+  });
+});
+
+describe("graphicDelivery", () => {
+  it("has no way to choose for an inline ^GF, and reads job while the design ships the bytes", () => {
+    expect(graphicDelivery(image(null), [entry])).toBeUndefined();
+    expect(graphicDelivery(image(), [entry])).toBe("job");
+    expect(graphicDelivery(image({ embedInZpl: false }), [entry])).toBe("setup");
+    expect(graphicDelivery(image({ embedInZpl: false }), undefined)).toBe("printer");
+  });
+
+  it("keeps a recall spelled with another extension in the choice, the entry named as the upload is", () => {
+    expect(graphicDelivery(image({ embedInZpl: false, ext: "PNG" }), undefined)).toBe("printer");
+    expect(graphicDelivery(image({ embedInZpl: false, ext: "PNG" }), [entry])).toBe("setup");
+    const provided = applyGraphicDelivery("setup", image({ embedInZpl: false, ext: "PNG" }), [entry]);
+    expect(provided).toEqual({ patch: { storedAs: recallOnly }, setupGraphics: [entry] });
+    const kept = applyGraphicDelivery("printer", image({ embedInZpl: false, ext: "PNG" }), undefined);
+    expect(kept).toEqual({ patch: null, setupGraphics: undefined });
+  });
+
+  it("encodes the profile entry once for setup, keeps an existing one, and drops it only for printer", () => {
+    const fresh = applyGraphicDelivery("setup", image(), undefined);
+    expect(fresh).toEqual({ patch: { storedAs: recallOnly, _gfaCache: GFA }, setupGraphics: [entry] });
+    const stale = [{ path: "R:LOGO.GRF", gfa: "^GFA,4,4,1,FFFFFFFF" }];
+    expect(applyGraphicDelivery("setup", image({ embedInZpl: true }), stale)).toEqual({ patch: { storedAs: recallOnly }, setupGraphics: stale });
+    expect(applyGraphicDelivery("job", image({ embedInZpl: false }), [entry])).toEqual({ patch: { storedAs: { device: "R", name: "LOGO", embedInZpl: true } }, setupGraphics: [entry] });
+    expect(applyGraphicDelivery("printer", image({ embedInZpl: false }), [entry])).toEqual({ patch: null, setupGraphics: undefined });
+  });
+
+  it("writes nothing the design or profile already holds", () => {
+    expect(applyGraphicDelivery("job", image(), [entry])).toEqual({ patch: null, setupGraphics: [entry] });
+    const kept = applyGraphicDelivery("setup", image({ embedInZpl: false }), [entry]);
+    expect(kept).toEqual({ patch: null, setupGraphics: [entry] });
+    const others = [{ path: "R:OTHER.GRF", gfa: GFA }];
+    expect(applyGraphicDelivery("printer", image({ embedInZpl: false }), others)).toEqual({ patch: null, setupGraphics: others });
+  });
+
+  it("knows when a job would ship nothing, whatever the flag says", () => {
+    expect(graphicJobShips(image())).toBe(true);
+    expect(graphicJobShips(image({ embedInZpl: false }))).toBe(true);
+    expect(graphicJobShips({ ...image(), _gfaCache: undefined })).toBe(false);
+    expect(graphicJobShips({ ...image(), _gfaCache: "^GFA,4,4,1," })).toBe(false);
+    expect(graphicJobShips(image(null))).toBe(false);
+  });
+
+  it("refuses setup for bytes the script cannot carry, and does nothing without a printer name", () => {
+    expect(applyGraphicDelivery("setup", { ...image(), _gfaCache: "^GFA,4,4,1," }, undefined)).toBeUndefined();
+    expect(applyGraphicDelivery("setup", image(null), undefined)).toBeUndefined();
+    const huge = `^GFA,600000,600000,1,${"F".repeat(1_200_000)}`;
+    expect(applyGraphicDelivery("setup", { ...image(), _gfaCache: huge }, undefined)).toEqual({ refused: "tooLarge" });
+  });
+});

packages/core/src/lib/resourceDelivery.ts

@@ -0,0 +1,84 @@
+import type { CustomFontMapping } from "../types/LabelConfig";
+import type { PrinterProfile, SetupGraphic } from "../types/PrinterProfile";
+import { setupGraphicOf, storedGraphicShips, type ImageProps } from "../registry/image";
+import { uploadedGraphicPath } from "./storagePath";
+import { findSetupEntry, withSetupEntry, withoutSetupEntry } from "./setupEntries";
+
+/** How a file reaches the printer: with every job, once through the setup script, or assumed to be there. */
+export type ResourceDelivery = "job" | "setup" | "printer";
+export const RESOURCE_DELIVERIES: readonly ResourceDelivery[] = ["job", "setup", "printer"];
+
+type SetupFont = NonNullable<PrinterProfile["setupFonts"]>[number];
+type FontShip = Pick<CustomFontMapping, "embedInZpl"> | undefined;
+
+/** An unchanged list comes back as the same reference, so a caller can skip the profile write. */
+function withoutEntry<T extends { path: string }>(list: readonly T[] | undefined, path: string): readonly T[] | undefined {
+  return findSetupEntry(list, path) ? withoutSetupEntry(list, path) : list;
+}
+
+/** The design's own choice wins: a font it ships prints from the job's bytes while the profile may still provision it. */
+export function fontDelivery(mapping: FontShip, path: string, setupFonts: readonly SetupFont[] | undefined): ResourceDelivery {
+  if (mapping?.embedInZpl) return "job";
+  return findSetupEntry(setupFonts, path) ? "setup" : "printer";
+}
+
+/** Undefined for an image without a printer name, which prints as inline ^GF and has no way to choose. */
+export function graphicDelivery(p: ImageProps, setupGraphics: readonly SetupGraphic[] | undefined): ResourceDelivery | undefined {
+  if (!p.storedAs) return undefined;
+  if (p.storedAs.embedInZpl !== false) return "job";
+  return findSetupEntry(setupGraphics, uploadedGraphicPath(p.storedAs)) ? "setup" : "printer";
+}
+
+/** The profile keeps its entry while the job ships the font too. Only "printer" says the entry is unwanted. */
+export function applyFontDelivery(
+  next: ResourceDelivery,
+  mapping: FontShip,
+  path: string,
+  setupFonts: readonly SetupFont[] | undefined,
+): { patch: { embedInZpl: true | undefined } | null; setupFonts: readonly SetupFont[] | undefined } {
+  const ships = mapping?.embedInZpl === true;
+  const patch = ships === (next === "job") ? null : { embedInZpl: next === "job" ? (true as const) : undefined };
+  if (next === "job") return { patch, setupFonts };
+  if (next === "setup") return { patch, setupFonts: findSetupEntry(setupFonts, path) ? setupFonts : withSetupEntry(setupFonts, { path }) };
+  return { patch, setupFonts: withoutEntry(setupFonts, path) };
+}
+
+/** Whether "job" would put bytes into the stream, so the choice never claims what the emit cannot send. */
+export function graphicJobShips(p: ImageProps): boolean {
+  return p.storedAs !== undefined && storedGraphicShips({ ...p, storedAs: { ...p.storedAs, embedInZpl: true } });
+}
+
+/** A delivery that provides the file names it as the upload does, so a recall spelled with another
+ *  extension follows the .GRF the job or the script sends. */
+export function providedGraphic(p: ImageProps): ImageProps {
+  if (!p.storedAs || p.storedAs.ext === undefined) return p;
+  const { ext: _ext, ...storedAs } = p.storedAs;
+  return { ...p, storedAs };
+}
+
+type GraphicDeliveryPatch =
+  | { patch: Partial<ImageProps> | null; setupGraphics: readonly SetupGraphic[] | undefined }
+  | { refused: "tooLarge" | "unshippable" };
+
+/** A profile entry the design already has stays as it is, so choosing "setup" encodes only when none exists. */
+export function applyGraphicDelivery(
+  next: ResourceDelivery,
+  p: ImageProps,
+  setupGraphics: readonly SetupGraphic[] | undefined,
+): GraphicDeliveryPatch | undefined {
+  const storedAs = p.storedAs;
+  if (!storedAs) return undefined;
+  const path = uploadedGraphicPath(storedAs);
+  const ships = storedAs.embedInZpl !== false;
+  if (next === "job") return { patch: ships ? null : { storedAs: { ...storedAs, embedInZpl: true } }, setupGraphics };
+  const recallOnly = { ...storedAs, embedInZpl: false };
+  if (next === "printer") return { patch: ships ? { storedAs: recallOnly } : null, setupGraphics: withoutEntry(setupGraphics, path) };
+  const provided = providedGraphic({ ...p, storedAs: recallOnly });
+  const patch = ships || storedAs.ext !== undefined ? { storedAs: provided.storedAs } : null;
+  if (findSetupEntry(setupGraphics, path)) return { patch, setupGraphics };
+  const verdict = setupGraphicOf(provided);
+  if (!verdict) return undefined;
+  if (verdict.fit !== "ok") return { refused: verdict.fit };
+  // The cache holds what was just sent, so the state reads current without a fresh encode.
+  return { patch: { storedAs: provided.storedAs, _gfaCache: verdict.entry.gfa }, setupGraphics: withSetupEntry(setupGraphics, verdict.entry) };
+}

packages/core/src/registry/image.ts

@@ -100,10 +100,8 @@ export interface ImageProps {
     recall?: 'IM';
     /** ^XG magnification as written, 1-10 per axis (spec p.373); the preview stays at stored size. */
     magnify?: { x: number; y: number };
-    /** Ship the bitmap bytes via `~DY` alongside the `^XG` reference.
-     *  Default true on first toggle so a single-job ZPL is self-contained.
-     *  False = recall-only: assume the file is already on printer storage,
-     *  emit only `^XG`. Mirrors the customFonts `embedInZpl` pattern. */
+    /** Ship the bitmap bytes via `~DY` alongside `^XG`. Undefined reads as true, so a fresh entry ships by default.
+     *  False is recall-only, assuming the file is already on printer storage. */
     embedInZpl?: boolean;
   };
 }

src/components/Fonts/FontManager.test.tsx

@@ -108,14 +108,70 @@ describe("FontManager manual mappings", () => {
   });
 });
 
-describe("FontManager embed toggle", () => {
+const choose = (r: ReturnType<typeof render>, option: string) => {
+  act(() => {
+    fireEvent.click(r.getAllByRole("button", { name: /^Delivery/ })[0] as HTMLElement);
+  });
+  act(() => {
+    r.getByRole("option", { name: option }).click();
+  });
+};
+
+describe("FontManager delivery", () => {
   it("writes only the flag on the mapping, the path being the identity", () => {
     act(() => useLabelStore.setState({ label: { widthMm: 70, heightMm: 40, dpmm: 8, customFonts: [{ alias: "M", path: "e:arial.ttf" }] } }));
     const r = render(<FontManager />);
+    choose(r, "With every job");
+    expect(useLabelStore.getState().label.customFonts).toEqual([{ alias: "M", path: "e:arial.ttf", embedInZpl: true }]);
+  });
+
+  it("moves a font from the job into the setup script and back out to the printer, the profile following each step", () => {
+    act(() => useLabelStore.setState({ label: { widthMm: 70, heightMm: 40, dpmm: 8, customFonts: [{ alias: "M", path: "E:ARIAL.TTF", embedInZpl: true }] } }));
+    const r = render(<FontManager />);
+    choose(r, "Once in the setup script");
+    expect(useLabelStore.getState().printerProfile.setupFonts).toEqual([{ path: "E:ARIAL.TTF" }]);
+    expect(useLabelStore.getState().label.customFonts).toEqual([{ alias: "M", path: "E:ARIAL.TTF", embedInZpl: undefined }]);
+    expect(r.getByText(/setup script of this printer profile/)).toBeTruthy();
+    choose(r, "Already on the printer");
+    expect(useLabelStore.getState().printerProfile.setupFonts).toBeUndefined();
+    expect(r.getByText(/default font/)).toBeTruthy();
+  });
+
+  it("keeps the profile entry when the job takes the font back", () => {
+    act(() => useLabelStore.setState({ label: { widthMm: 70, heightMm: 40, dpmm: 8, customFonts: [{ alias: "M", path: "E:ARIAL.TTF" }] }, printerProfile: { setupFonts: [{ path: "E:ARIAL.TTF" }] } }));
+    const r = render(<FontManager />);
+    choose(r, "With every job");
+    expect(useLabelStore.getState().printerProfile.setupFonts).toEqual([{ path: "E:ARIAL.TTF" }]);
+    expect(useLabelStore.getState().label.customFonts?.[0]?.embedInZpl).toBe(true);
+  });
+
+  it("blocks the job for a font without an alias, since no ^CW could name it", () => {
+    act(() => useLabelStore.setState({ label: { widthMm: 70, heightMm: 40, dpmm: 8 } }));
+    const r = render(<FontManager />);
     act(() => {
-      fireEvent.click(r.getByLabelText("Send with print job"));
+      fireEvent.click(r.getAllByRole("button", { name: /^Delivery/ })[0] as HTMLElement);
     });
-    expect(useLabelStore.getState().label.customFonts).toEqual([{ alias: "M", path: "e:arial.ttf", embedInZpl: true }]);
+    expect((r.getByRole("option", { name: "With every job" }) as HTMLElement).getAttribute("aria-disabled")).toBe("true");
+  });
+
+  it("steps the design back first on undo, spends nothing on a re-pick, and leaves the design still when only the profile moves", () => {
+    act(() => useLabelStore.setState({ label: { widthMm: 70, heightMm: 40, dpmm: 8, customFonts: [{ alias: "M", path: "E:ARIAL.TTF", embedInZpl: true }] } }));
+    const temporal = useLabelStore.temporal.getState();
+    const steps = () => useLabelStore.temporal.getState().pastStates.length;
+    const before = steps();
+    const r = render(<FontManager />);
+    choose(r, "With every job");
+    expect(steps()).toBe(before);
+    choose(r, "Once in the setup script");
+    // The design steps back first, and with the entry still in the profile the derivation reads job again.
+    act(() => temporal.undo());
+    expect(useLabelStore.getState().label.customFonts?.[0]?.embedInZpl).toBe(true);
+    expect(useLabelStore.getState().printerProfile.setupFonts).toEqual([{ path: "E:ARIAL.TTF" }]);
+    act(() => temporal.redo());
+    const label = useLabelStore.getState().label;
+    choose(r, "Already on the printer");
+    expect(useLabelStore.getState().label).toBe(label);
+    expect(useLabelStore.getState().printerProfile.setupFonts).toBeUndefined();
   });
 });