@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/designs/render-input.js

@@ -0,0 +1,59 @@
+import { imageBlob } from "../channels/repo.js";
+import { fillDocument, missingSentence, missingValues } from "./fields.js";
+import { formatLabels } from "./model.js";
+import { designDocumentSchema } from "./schema.js";
+import { designView } from "./service.js";
+export function prepare(db, designId, format) {
+    const design = designView(db, designId);
+    if (design === undefined)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "This design no longer exists. Go back to Designs to choose another.",
+        };
+    const parsed = designDocumentSchema.safeParse(design.document);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid",
+            message: "This picture has no formats yet. Press Turn into a designed piece to add text and formats, or download the picture itself.",
+        };
+    if (!parsed.data.formats.some((one) => one.format === format))
+        return {
+            ok: false,
+            reason: "invalid",
+            message: `${formatLabels[format]} isn't ticked for this design. Tick it under Formats, then download again.`,
+        };
+    const head = design.steps.find((step) => step.id === design.headStepId);
+    const blob = head === undefined || head.sha256 === null ? undefined : imageBlob(db, head.sha256);
+    if (head === undefined ||
+        blob === undefined ||
+        head.width === null ||
+        head.height === null ||
+        head.sha256 === null)
+        return {
+            ok: false,
+            reason: "not-ready",
+            message: "This design has no artwork yet. Press Make to draw it, then download again.",
+        };
+    const missing = missingValues({ ...parsed.data, picture: { ...parsed.data.picture, prompt: "" } }, design.values);
+    if (missing.length > 0)
+        return { ok: false, reason: "missing-values", message: missingSentence(missing) };
+    return {
+        ok: true,
+        value: {
+            doc: parsed.data,
+            values: design.values,
+            art: { ...blob, width: head.width, height: head.height, sha256: head.sha256 },
+        },
+    };
+}
+export function fileName(doc, values, format) {
+    const headline = fillDocument(doc, values).text.blocks.find((block) => block.text.trim() !== "")?.text ??
+        "design";
+    const safe = headline
+        .replace(/[^\p{L}\p{N}]+/gu, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60) || "design";
+    return `${safe}-${format}`;
+}

package/dist/slices/designs/render.js

@@ -0,0 +1,215 @@
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { errorText } from "../../kernel/errors.js";
+import { fontAdvances } from "../fonts/sfnt.js";
+import { checkText } from "./check-text.js";
+import { fillDocument } from "./fields.js";
+import { coverCrop, frames } from "./frames.js";
+import { layoutText } from "./layout.js";
+import { formatLabels } from "./model.js";
+import { renderArgs, shrinkArgs } from "./render-args.js";
+import { fileName, prepare } from "./render-input.js";
+// A finished piece, drawn on demand: the artwork cover-cropped to the format's frame and the
+// text layer set over it by libass, in a child ffmpeg (never this thread); print formats then
+// go to the PDF worker. One render at a time. Files are a cache under the data dir, named by
+// the design and a hash of everything drawn, so the same piece is drawn once; they are never
+// backed up and are deleted with the design.
+// 2: text measured with the font's own widths.
+export const rendererVersion = 2;
+export const rendersDir = (paths) => join(paths.dataDir, "design-renders");
+export function createDesignRenderer(deps) {
+    let queue = Promise.resolve();
+    const oneAtATime = (work) => {
+        const next = queue.then(work, work);
+        queue = next.catch(() => undefined);
+        return next;
+    };
+    const png = async (prepared, designId, format, signal) => {
+        const { doc, art, values } = prepared;
+        const frame = frames[format];
+        const entry = doc.formats.find((one) => one.format === format);
+        const focus = entry?.focus ?? { x: 0.5, y: 0.5 };
+        const textLayer = !doc.picture.aiText;
+        const fontIds = textLayer ? [...new Set(doc.text.blocks.map((block) => block.fontId))] : [];
+        const fonts = new Map();
+        for (const id of fontIds) {
+            try {
+                fonts.set(id, await deps.font(id));
+            }
+            catch (error) {
+                deps.log.write("warn", "designs.render.font", {
+                    detail: `${designId}: ${errorText(error)}`,
+                });
+            }
+        }
+        const filled = fillDocument(doc, values);
+        const key = createHash("sha256")
+            .update(JSON.stringify({
+            rendererVersion,
+            art: art.sha256,
+            format,
+            focus,
+            text: textLayer ? filled.text : null,
+            fonts: [...fonts].map(([id, font]) => [id, font.path, font.faceIndex]),
+        }))
+            .digest("hex")
+            .slice(0, 32);
+        const dir = join(rendersDir(deps.paths), designId);
+        const target = join(dir, `${format}-${key}.png`);
+        // Drawn before from the very same text, fonts and artwork, so it passed the checks then.
+        if (existsSync(target))
+            return { ok: true, value: target };
+        const checkFonts = {};
+        for (const [id, font] of fonts)
+            checkFonts[id] = {
+                name: font.name,
+                bytes: new Uint8Array(await readFile(font.path)),
+                faceIndex: font.faceIndex,
+            };
+        // Measured with the font's own widths; a font that can't be read is estimated.
+        const layoutFonts = Object.fromEntries([...fonts].map(([id, font]) => {
+            const bytes = checkFonts[id]?.bytes;
+            const advance = bytes === undefined ? undefined : fontAdvances(bytes, font.faceIndex);
+            return [id, { assName: font.assName, advance }];
+        }));
+        const layout = layoutText(frame, doc.text, values, layoutFonts);
+        if (textLayer) {
+            const problem = checkText({
+                text: doc.text,
+                values,
+                layout,
+                fonts: checkFonts,
+                formatLabel: formatLabels[format],
+            })[0];
+            if (problem !== undefined)
+                return { ok: false, reason: "invalid", message: problem.sentence };
+        }
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const work = mkdtempSync(join(dir, ".work-"));
+        try {
+            const artName = art.mime === "image/jpeg" ? "art.jpg" : "art.png";
+            writeFileSync(join(work, artName), art.bytes, { mode: 0o600 });
+            if (textLayer) {
+                mkdirSync(join(work, "fonts"), { mode: 0o700 });
+                for (const [index, font] of [...fonts.values()].entries())
+                    copyFileSync(font.path, join(work, "fonts", `font-${String(index)}${font.extension}`));
+                writeFileSync(join(work, "design.ass"), layout.ass, { mode: 0o600 });
+            }
+            await deps.runFfmpeg({
+                bin: deps.ffmpeg,
+                cwd: work,
+                args: renderArgs({
+                    art: artName,
+                    crop: coverCrop(art, frame, focus),
+                    frame,
+                    text: textLayer,
+                    output: "out.png",
+                }),
+                signal,
+                log: deps.log,
+                onProgress: () => undefined,
+            });
+            renameSync(join(work, "out.png"), target);
+            dropOlderDrawings(dir, format, target);
+            return { ok: true, value: target };
+        }
+        finally {
+            rmSync(work, { recursive: true, force: true });
+        }
+    };
+    return {
+        shrink: (bytes, signal) => oneAtATime(async () => {
+            const dir = rendersDir(deps.paths);
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            const work = mkdtempSync(join(dir, ".work-"));
+            try {
+                writeFileSync(join(work, "in"), bytes, { mode: 0o600 });
+                await deps.runFfmpeg({
+                    bin: deps.ffmpeg,
+                    cwd: work,
+                    args: shrinkArgs("in", "out.jpg"),
+                    signal,
+                    log: deps.log,
+                    onProgress: () => undefined,
+                });
+                return new Uint8Array(readFileSync(join(work, "out.jpg")));
+            }
+            finally {
+                rmSync(work, { recursive: true, force: true });
+            }
+        }),
+        render: (designId, format, type, signal) => oneAtATime(async () => {
+            const prepared = prepare(deps.db, designId, format);
+            if (!prepared.ok)
+                return prepared;
+            const frame = frames[format];
+            if (type === "pdf" && frame.pdf === undefined)
+                return {
+                    ok: false,
+                    reason: "invalid",
+                    message: `${formatLabels[format]} is a screen size, so it downloads as a PNG. Press Download PNG.`,
+                };
+            if (type === "png" && format === "brochure")
+                return {
+                    ok: false,
+                    reason: "invalid",
+                    message: "A brochure downloads as a PDF. Press Download PDF.",
+                };
+            const drawn = await png(prepared.value, designId, format, signal);
+            if (!drawn.ok)
+                return drawn;
+            const name = fileName(prepared.value.doc, prepared.value.values, format);
+            if (type === "png")
+                return { ok: true, value: { path: drawn.value, mime: "image/png", name: `${name}.png` } };
+            const pdfPath = drawn.value.replace(/\.png$/, ".pdf");
+            if (!existsSync(pdfPath)) {
+                if (deps.pdf === undefined)
+                    throw new Error("design PDFs need the PDF worker");
+                const page = frame.pdf;
+                const filled = fillDocument(prepared.value.doc, prepared.value.values);
+                const bytes = await deps.pdf(format === "brochure" && filled.brochure !== undefined
+                    ? {
+                        kind: "brochure",
+                        cover: new Uint8Array(readFileSync(drawn.value)),
+                        title: filled.brochure.title,
+                        markdown: filled.brochure.body,
+                        settings: filled.brochure.settings,
+                        writtenOn: deps.clock.now().toISOString(),
+                    }
+                    : {
+                        kind: "poster",
+                        png: new Uint8Array(readFileSync(drawn.value)),
+                        widthMm: page?.widthMm ?? 210,
+                        heightMm: page?.heightMm ?? 297,
+                    }, signal);
+                const partial = `${pdfPath}.part`;
+                writeFileSync(partial, bytes, { mode: 0o600 });
+                renameSync(partial, pdfPath);
+            }
+            return { ok: true, value: { path: pdfPath, mime: "application/pdf", name: `${name}.pdf` } };
+        }),
+    };
+}
+// What this format looked like before its newest drawing (PNG and PDF): nothing asks for those
+// again, so the cache holds one drawing per format.
+function dropOlderDrawings(dir, format, target) {
+    const keep = basename(target, ".png");
+    const drawing = new RegExp(`^(${format}-[a-f0-9]{32})\\.(png|pdf)$`);
+    for (const name of readdirSync(dir)) {
+        const stem = drawing.exec(name)?.[1];
+        if (stem !== undefined && stem !== keep)
+            rmSync(join(dir, name), { force: true });
+    }
+}
+// Every drawn file of a design, removed when it is purged. Design ids are letters, digits,
+// dashes and underscores (`requests.ts`), so one is always a single folder name.
+export function deleteRenders(paths, designId) {
+    const dir = join(rendersDir(paths), designId);
+    if (!/^[A-Za-z0-9_-]+$/.test(designId) || !existsSync(dir))
+        return 0;
+    const count = readdirSync(dir).length;
+    rmSync(dir, { recursive: true, force: true });
+    return count;
+}

package/dist/slices/designs/repo.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { designKinds } from "./model.js";
+// Rows of `designs` (migration 0070). Every list leaves out deleted designs
+// and the hidden samples a design template's editor redraws (`sample_of`).
+const designRow = z.object({
+    id: z.string(),
+    kind: z.enum(designKinds),
+    name: z.string(),
+    channel_id: z.string(),
+    project_id: z.string().nullable(),
+    template_id: z.string().nullable(),
+    template_version: z.number().nullable(),
+    schedule_id: z.string().nullable(),
+    schedule_run_id: z.string().nullable(),
+    document_json: z.string().nullable(),
+    values_json: z.string(),
+    head_step_id: z.string().nullable(),
+    sample_of: z.string().nullable(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    deleted_at: z.string().nullable(),
+});
+const valuesSchema = z.record(z.string(), z.string());
+export const notDesignSample = "sample_of IS NULL";
+function toDesign(raw) {
+    const row = designRow.parse(raw);
+    return {
+        id: row.id,
+        kind: row.kind,
+        name: row.name,
+        channelId: row.channel_id,
+        projectId: row.project_id,
+        templateId: row.template_id,
+        templateVersion: row.template_version,
+        scheduleId: row.schedule_id,
+        scheduleRunId: row.schedule_run_id,
+        document: row.document_json === null ? null : JSON.parse(row.document_json),
+        values: valuesSchema.catch({}).parse(JSON.parse(row.values_json)),
+        headStepId: row.head_step_id,
+        sampleOf: row.sample_of,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        deletedAt: row.deleted_at,
+    };
+}
+export function insertDesign(db, row) {
+    db.prepare(`INSERT INTO designs (id,kind,name,channel_id,project_id,template_id,template_version,schedule_id,schedule_run_id,document_json,values_json,sample_of,mutation_id,mutation_hash,created_at,updated_at)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(row.id, row.kind, row.name, row.channelId, row.projectId, row.templateId ?? null, row.templateVersion ?? null, row.scheduleId ?? null, row.scheduleRunId ?? null, row.document === null || row.document === undefined ? null : JSON.stringify(row.document), JSON.stringify(row.values), row.sampleOf ?? null, row.mutationId, row.mutationHash, row.at, row.at);
+}
+// Deleted designs included: the trash and a mutation replay read them too.
+export function designById(db, id) {
+    const row = db.prepare("SELECT * FROM designs WHERE id=?").get(id);
+    return row === undefined ? undefined : toDesign(row);
+}
+export function designByMutation(db, mutationId) {
+    const row = db.prepare("SELECT * FROM designs WHERE mutation_id=?").get(mutationId);
+    return row === undefined
+        ? undefined
+        : {
+            design: toDesign(row),
+            hash: row.mutation_hash === null ? null : String(row.mutation_hash),
+        };
+}
+export function listDesigns(db, filter = {}) {
+    const where = [`deleted_at IS NULL`, notDesignSample];
+    const params = [];
+    if (filter.projectId !== undefined) {
+        where.push("project_id=?");
+        params.push(filter.projectId);
+    }
+    return db
+        .prepare(`SELECT * FROM designs WHERE ${where.join(" AND ")} ORDER BY updated_at DESC, id`)
+        .all(...params)
+        .map(toDesign);
+}
+// Only when the row still has `baseUpdatedAt`; false when someone changed it meanwhile.
+export function updateDesign(db, id, baseUpdatedAt, changes, at) {
+    const sets = ["updated_at=?"];
+    const params = [at];
+    const set = (column, value) => {
+        sets.push(`${column}=?`);
+        params.push(value);
+    };
+    if (changes.name !== undefined)
+        set("name", changes.name);
+    if (changes.kind !== undefined)
+        set("kind", changes.kind);
+    if (changes.projectId !== undefined)
+        set("project_id", changes.projectId);
+    if (changes.document !== undefined)
+        set("document_json", JSON.stringify(changes.document));
+    if (changes.values !== undefined)
+        set("values_json", JSON.stringify(changes.values));
+    if (changes.headStepId !== undefined)
+        set("head_step_id", changes.headStepId);
+    const guard = baseUpdatedAt === undefined ? "" : " AND updated_at=?";
+    const result = db
+        .prepare(`UPDATE designs SET ${sets.join(",")} WHERE id=? AND deleted_at IS NULL${guard}`)
+        .run(...params, id, ...(baseUpdatedAt === undefined ? [] : [baseUpdatedAt]));
+    return Number(result.changes) > 0;
+}

package/dist/slices/designs/requests.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { castPerDesignMax, designKinds, designNameMax, instructionMax } from "./model.js";
+import { designDocumentSchema } from "./schema.js";
+// What the design routes and tools take. Browser-safe, like schema.ts.
+// Letters, digits, dashes and underscores: a design id names its folder of drawn files.
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z0-9_-]+$/);
+const mutationId = z.string().min(8).max(128);
+const sha256 = z.string().regex(/^[a-f0-9]{64}$/);
+export const designValuesSchema = z
+    .record(z.string().min(1).max(100), z.string().max(2000))
+    .refine((values) => Object.keys(values).length <= 100, {
+    message: "A design has at most 100 keywords.",
+});
+export const createDesignSchema = z
+    .object({
+    id,
+    mutationId,
+    kind: z.enum(designKinds),
+    name: z.string().trim().min(1).max(designNameMax),
+    channelId: id.optional(),
+    projectId: id.optional(),
+    // The picture to start from: an upload, or a version another design already has.
+    stagedFileId: id.optional(),
+    fromStepSha: sha256.optional(),
+    document: designDocumentSchema.optional(),
+    values: designValuesSchema.optional(),
+})
+    .strict()
+    .refine((input) => input.stagedFileId === undefined || input.fromStepSha === undefined, {
+    message: "Start from an upload or from an earlier version, not both.",
+});
+export const updateDesignSchema = z
+    .object({
+    baseUpdatedAt: z.string().min(1).max(64),
+    name: z.string().trim().min(1).max(designNameMax).optional(),
+    projectId: id.nullable().optional(),
+    document: designDocumentSchema.optional(),
+    values: designValuesSchema.optional(),
+})
+    .strict();
+export const quoteEditSchema = z
+    .object({
+    provider: z.string().min(1).max(64),
+    model: z.string().min(1).max(200),
+    castMemberIds: z.array(id).max(castPerDesignMax).optional(),
+})
+    .strict();
+export const editPictureSchema = z
+    .object({
+    mutationId,
+    fromStepId: id,
+    instruction: z.string().trim().min(1).max(instructionMax),
+    provider: z.string().min(1).max(64),
+    model: z.string().min(1).max(200),
+    castMemberIds: z.array(id).max(castPerDesignMax).optional(),
+    // The highest cost the person saw on the button, in dollars; 0 for plan usage.
+    acknowledgedHigh: z.number().min(0).max(1000),
+    // That the button said the price is unknown, and the person pressed it anyway.
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict();
+export const makeArtworkSchema = z
+    .object({
+    mutationId,
+    acknowledgedHigh: z.number().min(0).max(1000),
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict();
+// Try again asks the provider again, which is paid again: at the price the button showed.
+export const retryStepSchema = z
+    .object({
+    acknowledgedHigh: z.number().min(0).max(1000),
+    acknowledgedUnknown: z.boolean().optional(),
+})
+    .strict();
+export const setHeadSchema = z.object({ stepId: id }).strict();