@gentbajko/slopify 3.3.1 → 3.4.0

package/dist/slices/studio/plan.js

@@ -5,45 +5,13 @@ import { readSetting, writeSetting } from "../settings/repo.js";
 // upload is prepared; each of its shorts goes out at the first time its day and hour come round
 // after its own long video, so a plan never needs "next week" notes. The extension types the
 // times into Studio's schedule, in the browser's own time zone.
-export const weekdays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-const slotSchema = z.object({
-    day: z.number().int().min(0).max(6),
-    time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
-});
-const rowSchema = z.object({
-    name: z.string().trim().min(1).max(20),
-    long: slotSchema,
-    shorts: z.array(slotSchema).max(10),
-});
-export const postingPlanSchema = z.object({
-    timeZone: z.string().min(1).max(100),
-    rows: z.array(rowSchema).max(14),
-});
+export { postingPlanSchema, weekdays, } from "./plan-model.js";
+import { postingPlanSchema } from "./plan-model.js";
 export const postingPlanKey = "studio.postingPlan";
 const key = postingPlanKey;
-// Three long videos a week, five shorts each, the channel's own times.
-export function defaultPlan(timeZone) {
-    const at = (day, time) => ({ day, time });
-    return {
-        timeZone,
-        rows: [
-            {
-                name: "A",
-                long: at(0, "20:00"),
-                shorts: [at(1, "00:00"), at(1, "17:00"), at(2, "00:00"), at(2, "17:00"), at(3, "17:00")],
-            },
-            {
-                name: "B",
-                long: at(2, "20:00"),
-                shorts: [at(3, "00:00"), at(4, "00:00"), at(4, "17:00"), at(5, "17:00"), at(6, "17:00")],
-            },
-            {
-                name: "C",
-                long: at(4, "20:00"),
-                shorts: [at(5, "00:00"), at(6, "00:00"), at(6, "21:00"), at(0, "00:00"), at(0, "17:00")],
-            },
-        ],
-    };
+// No plan until one is made: nothing is scheduled, and Prepare upload says so.
+export function emptyPlan(timeZone) {
+    return { timeZone, rows: [] };
 }
 export function localTimeZone() {
     return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
@@ -57,9 +25,9 @@ export function readPlan(db) {
                 return parsed.data;
         }
         catch {
-            // A broken setting reads as the default plan.
+            // A broken setting reads as no plan.
         }
-    return defaultPlan(localTimeZone());
+    return emptyPlan(localTimeZone());
 }
 export function writePlan(db, plan) {
     writeSetting(db, key, JSON.stringify(postingPlanSchema.parse(plan)));
@@ -123,68 +91,17 @@ export function nextOccurrence(timeZone, slot, after) {
     }
     return new Date(after.getTime() + 7 * 24 * 60 * 60 * 1000);
 }
-// The coming long-video slots in time order, from `now` (a slot starting within the hour is
-// too close to prepare), over `weeks` weeks.
-export function comingSlots(plan, now, weeks = 8) {
-    const soonest = now.getTime() + 60 * 60 * 1000;
-    const start = localDate(plan.timeZone, now);
-    const slots = [];
-    for (let day = 0; day < weeks * 7; day += 1) {
-        const date = addDays(start, day);
-        for (const row of plan.rows) {
-            if (row.long.day !== date.weekday)
-                continue;
-            const at = zonedInstant(plan.timeZone, date, row.long.time);
-            if (at.getTime() >= soonest)
-                slots.push({ row: row.name, at });
-        }
+// Every time the slot's day and hour come round from `from` (inclusive) to `until`.
+export function zonedTimes(timeZone, slot, from, until) {
+    const times = [];
+    let date = localDate(timeZone, new Date(from.getTime() - 24 * 60 * 60 * 1000));
+    for (;; date = addDays(date, 1)) {
+        if (date.weekday !== slot.day)
+            continue;
+        const at = zonedInstant(timeZone, date, slot.time);
+        if (at.getTime() >= until.getTime())
+            return times;
+        if (at.getTime() >= from.getTime())
+            times.push(at);
     }
-    return slots
-        .toSorted((left, right) => left.at.getTime() - right.at.getTime())
-        .map((slot) => ({ row: slot.row, longAt: slot.at.toISOString() }));
-}
-export function scheduleOf(plan, slot) {
-    const row = plan.rows.find((one) => one.name === slot.row);
-    const longAt = new Date(slot.longAt);
-    return {
-        ...slot,
-        shortsAt: (row?.shorts ?? []).map((short) => nextOccurrence(plan.timeZone, short, longAt).toISOString()),
-    };
-}
-// The project's slot: the one it was given, else the next free one, kept from now on. A project
-// set to "Not scheduled" keeps an empty row, so it isn't given one again.
-export function assignedSlot(db, plan, projectId, now) {
-    const row = db
-        .prepare("SELECT row_name, long_at FROM upload_slots WHERE project_id=?")
-        .get(projectId);
-    if (row !== undefined)
-        return String(row.long_at) === ""
-            ? undefined
-            : { row: String(row.row_name), longAt: String(row.long_at) };
-    const free = freeSlots(db, plan, now, 1)[0];
-    if (free === undefined)
-        return undefined;
-    setSlot(db, projectId, free, now);
-    return free;
-}
-export function freeSlots(db, plan, now, count) {
-    const taken = new Set(db
-        .prepare("SELECT long_at FROM upload_slots")
-        .all()
-        .map((row) => String(row.long_at)));
-    return comingSlots(plan, now)
-        .filter((slot) => !taken.has(slot.longAt))
-        .slice(0, count);
-}
-export function setSlot(db, projectId, slot, now) {
-    db.prepare(`INSERT INTO upload_slots(project_id,row_name,long_at,assigned_at) VALUES (?,?,?,?)
-     ON CONFLICT(project_id) DO UPDATE SET row_name=excluded.row_name, long_at=excluded.long_at,
-       assigned_at=excluded.assigned_at`).run(projectId, slot.row, slot.longAt, now.toISOString());
-}
-// "Not scheduled": the project takes no slot until one is chosen for it.
-export function unschedule(db, projectId, now) {
-    setSlot(db, projectId, { row: "", longAt: "" }, now);
-}
-export function clearSlot(db, projectId) {
-    db.prepare("DELETE FROM upload_slots WHERE project_id=?").run(projectId);
 }

package/dist/slices/studio/releases.js

@@ -0,0 +1,140 @@
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { zonedTimes } from "./plan.js";
+import { leadHoursDefault, leadHoursMax } from "./plan-model.js";
+const hourMs = 60 * 60 * 1000;
+export const leadHoursKey = "studio.leadHours";
+const leadKey = leadHoursKey;
+export function readLeadHours(db) {
+    const stored = Number(readSetting(db, leadKey));
+    return Number.isInteger(stored) && stored >= 1 && stored <= leadHoursMax
+        ? stored
+        : leadHoursDefault;
+}
+export function writeLeadHours(db, hours) {
+    writeSetting(db, leadKey, String(hours));
+}
+export function releasesOf(db, projectId) {
+    return db
+        .prepare("SELECT short, release_at, line, by FROM releases WHERE project_id=? ORDER BY short")
+        .all(projectId)
+        .map((row) => ({
+        short: Number(row.short),
+        at: String(row.release_at),
+        line: row.line === null ? null : String(row.line),
+        by: row.by === "person" ? "person" : "plan",
+    }));
+}
+export function allReleases(db) {
+    return db
+        .prepare("SELECT project_id, short, release_at, line, by FROM releases WHERE release_at != '' ORDER BY release_at")
+        .all()
+        .map((row) => ({
+        projectId: String(row.project_id),
+        short: Number(row.short),
+        at: String(row.release_at),
+        line: row.line === null ? null : String(row.line),
+        by: row.by === "person" ? "person" : "plan",
+    }));
+}
+function write(db, projectId, release, now) {
+    db.prepare(`INSERT INTO releases(project_id,short,release_at,line,by,set_at) VALUES (?,?,?,?,?,?)
+     ON CONFLICT(project_id,short) DO UPDATE SET release_at=excluded.release_at,
+       line=excluded.line, by=excluded.by, set_at=excluded.set_at`).run(projectId, release.short, release.at, release.line, release.by, now.toISOString());
+}
+// The hours other releases already take: two never go out in the same hour.
+function takenHours(db, exceptProject) {
+    return new Set(allReleases(db)
+        .filter((release) => release.projectId !== exceptProject)
+        .map((release) => Math.floor(Date.parse(release.at) / hourMs)));
+}
+const fits = (line, series) => line.series === "" || line.series === series;
+// The plan's long-video times from `from` to `until`, in order, each with its line.
+export function lineSlots(plan, from, until) {
+    return plan.rows
+        .flatMap((line) => zonedTimes(plan.timeZone, line.long, from, until).map((at) => ({
+        row: line.name,
+        series: line.series,
+        longAt: at.toISOString(),
+    })))
+        .toSorted((left, right) => Date.parse(left.longAt) - Date.parse(right.longAt));
+}
+// The coming long-video times a project of `series` may take: far enough ahead to upload in
+// time, of a line that takes its series, in an hour no other release has.
+export function freeSlots(db, plan, series, now, count, exceptProject) {
+    const taken = takenHours(db, exceptProject);
+    const from = new Date(now.getTime() + readLeadHours(db) * hourMs);
+    return lineSlots(plan, from, new Date(from.getTime() + 8 * 7 * 24 * hourMs))
+        .filter((slot) => {
+        const line = plan.rows.find((one) => one.name === slot.row);
+        return (line !== undefined &&
+            fits(line, series) &&
+            !taken.has(Math.floor(Date.parse(slot.longAt) / hourMs)));
+    })
+        .slice(0, count)
+        .map(({ row, longAt }) => ({ row, longAt }));
+}
+// Gives a finished project its release times where it has none: the long video the next free
+// slot of its series, each short the line's first short time after the one before it in an
+// hour no other release has. A project set to "not scheduled" is left so.
+export function planReleases(db, plan, project, now) {
+    let releases = releasesOf(db, project.id);
+    let long = releases.find((release) => release.short === 0);
+    if (long === undefined) {
+        const slot = freeSlots(db, plan, project.series, now, 1, project.id)[0];
+        if (slot === undefined)
+            return;
+        long = { short: 0, at: slot.longAt, line: slot.row, by: "plan" };
+        write(db, project.id, long, now);
+        releases = releasesOf(db, project.id);
+    }
+    if (long.at === "")
+        return;
+    const line = plan.rows.find((one) => one.name === long?.line);
+    if (line === undefined || line.shorts.length === 0)
+        return;
+    const taken = takenHours(db, project.id);
+    for (const release of releases)
+        if (release.at !== "")
+            taken.add(Math.floor(Date.parse(release.at) / hourMs));
+    const longAt = new Date(long.at);
+    const times = line.shorts
+        .flatMap((slot) => zonedTimes(plan.timeZone, slot, longAt, new Date(longAt.getTime() + 5 * 7 * 24 * hourMs)))
+        .toSorted((left, right) => left.getTime() - right.getTime());
+    let after = longAt.getTime();
+    for (let short = 1; short <= project.shorts; short += 1) {
+        const kept = releases.find((release) => release.short === short);
+        if (kept !== undefined) {
+            if (kept.at !== "")
+                after = Math.max(after, Date.parse(kept.at));
+            continue;
+        }
+        const at = times.find((time) => time.getTime() > after && !taken.has(Math.floor(time.getTime() / hourMs)));
+        if (at === undefined)
+            return;
+        taken.add(Math.floor(at.getTime() / hourMs));
+        after = at.getTime();
+        write(db, project.id, { short, at: at.toISOString(), line: line.name, by: "plan" }, now);
+    }
+}
+// The person sets one release: an ISO time, or "" for "not scheduled". Moving the long video
+// drops the shorts' plan-placed times, so they are planned again after it.
+export function setRelease(db, projectId, short, at, line, now) {
+    write(db, projectId, { short, at, line, by: "person" }, now);
+    if (short === 0)
+        db.prepare("DELETE FROM releases WHERE project_id=? AND short>0 AND by='plan'").run(projectId);
+}
+export function scheduleOf(db, projectId) {
+    const releases = releasesOf(db, projectId);
+    const long = releases.find((release) => release.short === 0);
+    if (long === undefined || long.at === "")
+        return undefined;
+    const last = Math.max(0, ...releases.map((release) => release.short));
+    return {
+        row: long.line ?? "",
+        longAt: long.at,
+        shortsAt: Array.from({ length: last }, (_, index) => {
+            const at = releases.find((release) => release.short === index + 1)?.at;
+            return at === undefined || at === "" ? null : at;
+        }),
+    };
+}

package/dist/slices/studio/videos.js

@@ -26,6 +26,7 @@ function rowOf(row) {
         commentMessage: typeof row.comment_message === "string" ? row.comment_message : null,
         abMessage: typeof row.ab_message === "string" ? row.ab_message : null,
         abAt: typeof row.ab_at === "string" ? row.ab_at : null,
+        checks: typeof row.checks === "string" ? row.checks : null,
     };
 }
 // Records (or replaces) the video an upload became: "filled" from the upload dialog, "done"
@@ -92,3 +93,7 @@ export function previousLongVideo(db, projectId) {
         .get(projectId, own?.recorded_at ?? null, own?.recorded_at ?? null);
     return typeof row?.video_id === "string" ? row.video_id : undefined;
 }
+// Studio's word on a known video's checks, read from its Content list row.
+export function setChecks(db, videoId, checks) {
+    db.prepare("UPDATE youtube_videos SET checks=? WHERE video_id=?").run(checks, videoId);
+}