@design-edito/tools 0.3.16 → 0.3.17

package/chunks/chunk-K5UF634H.js

@@ -0,0 +1,25 @@
+// src/agnostic/arrays/random-pick/index.ts
+function randomPick(arr, exclude = []) {
+  const filteredArr = [...arr].filter((elt) => !exclude.includes(elt));
+  const length = filteredArr.length;
+  if (length === 0) throw new Error("Array length must be at least 1 after exclusion");
+  const pos = Math.floor(Math.random() * length);
+  const found = filteredArr[pos];
+  return found;
+}
+function randomPickMany(howMuch, arr, exclude = []) {
+  const grindedArr = [...arr];
+  const pickedSelection = [];
+  for (let i = 0; i < howMuch; i++) {
+    const picked = randomPick(grindedArr, exclude);
+    const indexOfPicked = grindedArr.indexOf(picked);
+    grindedArr.splice(indexOfPicked, 1);
+    pickedSelection.push(picked);
+  }
+  return pickedSelection;
+}
+
+export {
+  randomPick,
+  randomPickMany
+};

package/chunks/chunk-KKYEOIJI.js

@@ -0,0 +1,195 @@
+import {
+  toError
+} from "./chunk-YWSXCFYY.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+import {
+  subtitles
+} from "./chunk-3DNVFA25.js";
+import {
+  clss
+} from "./chunk-TRFZSKNB.js";
+import {
+  mergeClassNames
+} from "./chunk-OFCSIK6J.js";
+
+// src/components/Subtitles/index.tsx
+import {
+  useCallback,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+
+// src/components/Subtitles/utils.ts
+var getTimecodeToMs = (timecode) => {
+  const [hours = "0", minutes = "0", secondsAndMs = "0,0"] = timecode.split(":");
+  const [seconds = "0", milliseconds = "0"] = secondsAndMs.split(",");
+  let result = parseInt(hours) * 60 * 60 * 1e3;
+  result += parseInt(minutes) * 60 * 1e3;
+  result += parseInt(seconds) * 1e3;
+  result += parseInt(milliseconds);
+  return result;
+};
+var parseSubs = (rawSubs) => {
+  const numberRegex = /^\d+$/;
+  const timecodeRegex = /^[0-9]+:[0-9]+:[0-9]+,[0-9]+\s*-->\s*[0-9]+:[0-9]+:[0-9]+,[0-9]+$/;
+  const parsedSubs = [];
+  rawSubs.split("\n").forEach((line) => {
+    if (line.trim() === "") return;
+    const lastParsedSub = parsedSubs[parsedSubs.length - 1];
+    const matchId = line.match(numberRegex);
+    const matchTimecode = line.match(timecodeRegex);
+    if (matchId !== null) {
+      if (lastParsedSub === void 0 || lastParsedSub.content !== void 0) {
+        const parsedSub = { id: parseInt(line) };
+        parsedSubs.push(parsedSub);
+        return;
+      }
+    }
+    if (matchTimecode !== null) {
+      if (lastParsedSub?.id !== void 0) {
+        const [rawStart = "", rawEnd = ""] = line.split("-->");
+        const startTime = rawStart.trim();
+        const endTime = rawEnd.trim();
+        lastParsedSub.start = getTimecodeToMs(startTime);
+        lastParsedSub.end = getTimecodeToMs(endTime);
+        return;
+      }
+    }
+    if (lastParsedSub?.id !== void 0 && lastParsedSub?.start !== void 0 && lastParsedSub?.end !== void 0) {
+      if (lastParsedSub?.content !== void 0) {
+        lastParsedSub.content += "\n" + line;
+        return;
+      }
+      lastParsedSub.content = line;
+    }
+  });
+  return parsedSubs;
+};
+var computeSubGroupsWithBoundaries = (subsGroups, highestSubId) => {
+  const fallback = [{ startId: 1, endId: highestSubId }];
+  if (subsGroups === void 0 || subsGroups.length === 0) return fallback;
+  const emptySubGroupBoundaries = [];
+  return subsGroups?.reduce(
+    (acc, curr, currIndex) => {
+      const lastInAcc = acc[acc.length - 1];
+      const startId = lastInAcc === void 0 ? 1 : lastInAcc.endId + 1;
+      const endId = curr;
+      if (currIndex === (subsGroups?.length ?? 0) - 1 && endId !== highestSubId) {
+        return [
+          ...acc,
+          { startId, endId },
+          { startId: endId + 1, endId: highestSubId }
+        ];
+      }
+      return [...acc, { startId, endId }];
+    },
+    emptySubGroupBoundaries
+  ) ?? fallback;
+};
+var getCurrentGroup = (subsGroupsWithBoundaries, lastPrevSubId, isEnded) => {
+  const previousGroups = subsGroupsWithBoundaries.filter((group) => group.startId <= (lastPrevSubId ?? 0));
+  if (previousGroups.length === 0) return isEnded === true ? subsGroupsWithBoundaries[subsGroupsWithBoundaries.length - 1] : subsGroupsWithBoundaries[0];
+  return previousGroups[previousGroups.length - 1];
+};
+
+// src/components/Subtitles/styles.module.css
+var styles_default = {};
+
+// src/components/Subtitles/index.tsx
+import { jsx } from "react/jsx-runtime";
+var Subtitles = ({
+  src,
+  srtFileContent,
+  subsGroups,
+  timecodeMs,
+  isEnded,
+  className,
+  onLoaded,
+  onParsed,
+  onLoadFailed
+}) => {
+  const [isLoading, setIsLoading] = useState(false);
+  const [loadError, setLoadError] = useState(null);
+  const [parsedSubs, setParsedSubs] = useState([]);
+  const pParsedSubs = useRef(parsedSubs);
+  useEffect(() => {
+    if (pParsedSubs.current === parsedSubs) return;
+    onParsed?.(parsedSubs);
+  }, [parsedSubs]);
+  const fetchAndParseSubs = useCallback(async (src2, srtFileContent2) => {
+    if (src2 === void 0) return;
+    if (srtFileContent2 !== void 0) return setParsedSubs(parseSubs(srtFileContent2));
+    setIsLoading(true);
+    setLoadError(null);
+    try {
+      const response = await fetch(src2);
+      const srtContent = await response.text();
+      onLoaded?.(srtContent);
+      const parsedSubs2 = parseSubs(srtContent);
+      setParsedSubs(parsedSubs2);
+    } catch (error) {
+      setLoadError(error instanceof Error ? error : new Error(unknownToString(error)));
+      console.error(error);
+      onLoadFailed?.(toError(error));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [onLoadFailed, onLoaded]);
+  useEffect(() => {
+    fetchAndParseSubs(src, srtFileContent).catch((error) => {
+      console.error(error);
+    });
+  }, [fetchAndParseSubs, src, srtFileContent]);
+  const c = clss(subtitles, { cssModule: styles_default });
+  const rootClss = mergeClassNames(
+    c(null, {
+      loading: isLoading,
+      error: loadError !== null
+    }),
+    className
+  );
+  const prevSubs = parsedSubs.filter(({ start }) => start != null && start < (timecodeMs ?? 0));
+  const lastPrevSub = prevSubs[prevSubs.length - 1];
+  const highestSubId = Math.max(...parsedSubs.map((sub) => sub.id));
+  const subsGroupsWithBoundaries = computeSubGroupsWithBoundaries(subsGroups, highestSubId);
+  const currentGroup = getCurrentGroup(subsGroupsWithBoundaries, lastPrevSub?.id, isEnded);
+  return /* @__PURE__ */ jsx("div", { className: rootClss, children: timecodeMs !== void 0 && parsedSubs.length > 0 && subsGroupsWithBoundaries.map((group) => {
+    const groupSubs = parsedSubs.filter((sub) => sub.id >= group.startId && sub.id <= group.endId);
+    const totalSubs = groupSubs.length;
+    const groupClass = c("group", { curr: currentGroup?.startId === group.startId });
+    const subsNodes = groupSubs.map((sub, subIndex) => {
+      let subText = sub.content?.trim() ?? "";
+      if (subIndex !== totalSubs - 1) subText += " ";
+      const subClass = c("sub", {
+        prev: sub.start !== void 0 && lastPrevSub?.start !== void 0 && sub.start <= lastPrevSub.start,
+        curr: sub.start !== void 0 && timecodeMs >= sub.start && sub.end !== void 0 && timecodeMs <= sub.end
+      });
+      return /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: subClass,
+          "data-sub-pos": sub.id,
+          children: subText
+        },
+        sub.id
+      );
+    });
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: groupClass,
+        "data-start-sub-pos": group.startId,
+        "data-end-sub-pos": group.endId,
+        children: subsNodes
+      },
+      group.startId
+    );
+  }) });
+};
+
+export {
+  Subtitles
+};

package/chunks/chunk-LJ5MGLLU.js

@@ -0,0 +1,56 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@aws-s3/storage/file/move/index.ts
+import {
+  HeadObjectCommand,
+  CopyObjectCommand,
+  DeleteObjectCommand
+} from "@aws-sdk/client-s3";
+async function move(client, bucketName, sourcePath, targetPath, options) {
+  const {
+    copyOptions,
+    deleteOptions,
+    overwrite = false
+  } = options ?? {};
+  try {
+    if (!overwrite) {
+      try {
+        await client.send(new HeadObjectCommand({ Bucket: bucketName, Key: targetPath }));
+        return makeFailure(`Object already exists at ${targetPath}.`);
+      } catch (err) {
+        const notFound = err.$metadata?.httpStatusCode === 404 || err.name === "NotFound" || err.Code === "NotFound" || err.Code === "NoSuchKey";
+        if (!notFound) {
+          return makeFailure(unknownToString(err));
+        }
+      }
+    }
+    await client.send(
+      new CopyObjectCommand({
+        Bucket: bucketName,
+        Key: targetPath,
+        CopySource: `${bucketName}/${sourcePath}`,
+        ...copyOptions
+      })
+    );
+    await client.send(
+      new DeleteObjectCommand({
+        Bucket: bucketName,
+        Key: sourcePath,
+        ...deleteOptions
+      })
+    );
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  move
+};

package/chunks/chunk-LUAYN7VJ.js

@@ -0,0 +1,27 @@
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/agnostic/misc/outcome/index.ts
+var outcome_exports = {};
+__export(outcome_exports, {
+  make: () => make,
+  makeFailure: () => makeFailure,
+  makeSuccess: () => makeSuccess
+});
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+function make(success, payloadOrError) {
+  return success ? makeSuccess(payloadOrError) : makeFailure(payloadOrError);
+}
+
+export {
+  makeSuccess,
+  makeFailure,
+  make,
+  outcome_exports
+};

package/chunks/chunk-MDVGDZU6.js

@@ -0,0 +1,25 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+
+// src/node/images/transform/operations/saturate/index.ts
+import z from "zod";
+function isSaturateOperationParams(obj) {
+  const schema = z.object({
+    saturation: z.number().optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
+}
+async function saturate(sharpInstance, params) {
+  return sharpInstance.modulate({
+    saturation: params.saturation
+  });
+}
+
+export {
+  isSaturateOperationParams,
+  saturate
+};

package/chunks/chunk-ML22TIBW.js

@@ -0,0 +1,37 @@
+import {
+  toSharpColor
+} from "./chunk-HMMPT3UM.js";
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  isColor
+} from "./chunk-OBSTP7YR.js";
+
+// src/node/images/transform/operations/extend/index.ts
+import z from "zod";
+function isExtendOperationParams(obj) {
+  const schema = z.object({
+    left: z.number().optional(),
+    right: z.number().optional(),
+    top: z.number().optional(),
+    bottom: z.number().optional(),
+    extendWith: z.optional(z.enum(["background", "copy", "repeat", "mirror"])),
+    background: z.custom(isColor).optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
+}
+async function extend(sharpInstance, params) {
+  return sharpInstance.extend({
+    ...params,
+    background: params.background !== void 0 ? toSharpColor(params.background) : void 0
+  });
+}
+
+export {
+  isExtendOperationParams,
+  extend
+};

package/chunks/chunk-MO4TRYNI.js

@@ -0,0 +1,29 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/file/remove/index.ts
+async function remove(bucket, targetPath, options) {
+  const { fileOptions, deleteOptions, ignoreMissing = true } = options ?? {};
+  try {
+    const file = bucket.file(targetPath, fileOptions);
+    const [exists] = await file.exists();
+    if (!exists) {
+      if (ignoreMissing) return makeSuccess(true);
+      return makeFailure(`File not found at ${targetPath}.`);
+    }
+    await file.delete(deleteOptions);
+    return makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+export {
+  remove
+};

package/chunks/chunk-NIBRPZJD.js

@@ -0,0 +1,58 @@
+import {
+  toSharpColor
+} from "./chunk-HMMPT3UM.js";
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  isColor
+} from "./chunk-OBSTP7YR.js";
+
+// src/node/images/transform/operations/resize/index.ts
+import z from "zod";
+function isResizeOperationParams(obj) {
+  const schema = z.object({
+    width: z.number().optional(),
+    height: z.number().optional(),
+    fit: z.enum([
+      "contain",
+      "cover",
+      "fill",
+      "inside",
+      "outside"
+    ]).optional(),
+    position: z.union([
+      z.number(),
+      z.string()
+    ]).optional(),
+    background: z.custom(isColor).optional(),
+    kernel: z.enum([
+      "nearest",
+      "cubic",
+      "linear",
+      "mitchell",
+      "lanczos2",
+      "lanczos3",
+      "mks2013",
+      "mks2021"
+    ]).optional(),
+    withoutEnlargement: z.boolean().optional(),
+    withoutReduction: z.boolean().optional(),
+    fastShrinkOnLoad: z.boolean().optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
+}
+async function resize(sharpInstance, params) {
+  return sharpInstance.resize({
+    ...params,
+    background: params.background !== void 0 ? toSharpColor(params.background) : void 0
+  });
+}
+
+export {
+  isResizeOperationParams,
+  resize
+};

package/chunks/chunk-OAX7GS7C.js

@@ -0,0 +1,36 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/directory/move-dir/index.ts
+async function moveDir(bucket, sourceDir, targetDir, options) {
+  const { fileOptions, copyOptions, deleteOptions, overwrite = false } = options ?? {};
+  const from = sourceDir.endsWith("/") ? sourceDir : `${sourceDir}/`;
+  const to = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
+  try {
+    const [files] = await bucket.getFiles({ prefix: from });
+    for (const f of files) {
+      const rel = f.name.substring(from.length);
+      const dest = `${to}${rel}`;
+      const srcFile = bucket.file(f.name, fileOptions);
+      const destFile = bucket.file(dest, fileOptions);
+      if (!overwrite) {
+        const [exists] = await destFile.exists();
+        if (exists) throw new Error(`File already exists at ${dest}.`);
+      }
+      await srcFile.copy(dest, copyOptions);
+      await srcFile.delete(deleteOptions);
+    }
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  moveDir
+};