@smallpen/local-package 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/draft-import.mjs

@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto";
 import {
-  lstat,
   mkdir,
   mkdtemp,
   rename,
@@ -21,6 +20,7 @@ import {
   SmallPenError,
 } from "@smallpen/core";
 
+import { pathExists } from "./fs-utils.mjs";
 import {
   ByteBuffer,
   compileSchema,
@@ -170,16 +170,6 @@ function inspectSvg(bytes) {
   return { height, width };
 }
 
-async function pathExists(path) {
-  try {
-    await lstat(path);
-    return true;
-  } catch (error) {
-    if (error?.code === "ENOENT") return false;
-    throw error;
-  }
-}
-
 export async function writeDraftPackage(outputValue, values) {
   const output = resolve(outputValue);
   if (!output.endsWith(".smallpen")) {

package/src/font-convert.mjs

@@ -20,7 +20,9 @@ function matches(bytes, signature) {
 }
 
 export function inspectFont(bytes, mimeType) {
-  const signature = FONT_SIGNATURES[mimeType];
+  const signature = Object.hasOwn(FONT_SIGNATURES, mimeType)
+    ? FONT_SIGNATURES[mimeType]
+    : undefined;
   if (!signature || !matches(bytes, signature)) {
     failFont(
       "invalid_font_blob",
@@ -108,6 +110,26 @@ export function sfntToWoff(bytes, mimeType) {
   return output;
 }
 
+// Penpot names a Font Variant without a stored name from its weight and
+// style (app.common.media/font-display-variant), e.g. "Bold Italic".
+const FONT_WEIGHT_NAMES = {
+  100: "Hairline",
+  200: "Extra Light",
+  300: "Light",
+  400: "Regular",
+  500: "Medium",
+  600: "Semi Bold",
+  700: "Bold",
+  800: "Extra Bold",
+  900: "Black",
+  950: "Extra Black",
+};
+
+export function fontVariantName(weight, style) {
+  const base = FONT_WEIGHT_NAMES[Number(weight)] ?? String(weight);
+  return style === "italic" ? `${base} Italic` : base;
+}
+
 export function prepareFontFiles(input) {
   const files = {};
   for (const [mimeType, bytes] of Object.entries(input)) {

package/src/fs-utils.mjs

@@ -0,0 +1,95 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { isAbsolute, relative } from "node:path";
+
+export function isWithinRoot(rootPath, candidatePath) {
+  const child = relative(rootPath, candidatePath);
+  return child === "" || (!child.startsWith("..") && !isAbsolute(child));
+}
+
+export async function pathExists(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+// Reads a file only when it is a regular file. A FIFO or device in a Package
+// (an archive can carry one) would otherwise block the read, the write lock
+// and a thread-pool thread forever. Opening without blocking and checking the
+// opened handle leaves no gap between the check and the read.
+//
+// With `maxBytes`, a file larger than the limit fails with code EFILETOOBIG
+// (and `size`/`maxBytes` on the error) instead of being buffered whole; the
+// read itself is bounded too, so a file growing after the size check cannot
+// pass the limit either.
+export async function readRegularFile(path, encoding, { maxBytes } = {}) {
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+  try {
+    const info = await handle.stat();
+    if (!info.isFile()) {
+      const error = new Error(`Not a regular file: ${path}`);
+      error.code = "ENOTREGULAR";
+      throw error;
+    }
+    if (maxBytes === undefined) return await handle.readFile(encoding);
+    const tooBig = (size) =>
+      Object.assign(new Error(`File exceeds ${maxBytes} bytes: ${path}`), {
+        code: "EFILETOOBIG",
+        maxBytes,
+        size,
+      });
+    if (info.size > maxBytes) throw tooBig(info.size);
+    const chunks = [];
+    let length = 0;
+    while (length <= maxBytes) {
+      const chunk = Buffer.alloc(Math.min(Math.max(info.size - length, 0), maxBytes - length) + 1);
+      const { bytesRead } = await handle.read(chunk, 0, chunk.length, length);
+      if (bytesRead === 0) break;
+      chunks.push(chunk.subarray(0, bytesRead));
+      length += bytesRead;
+    }
+    if (length > maxBytes) throw tooBig(length);
+    const bytes = Buffer.concat(chunks, length);
+    return encoding ? bytes.toString(encoding) : bytes;
+  } finally {
+    await handle.close();
+  }
+}
+
+// Writes a new file and flushes it to stable storage before returning. The
+// file must not exist yet: commits never truncate an inode in place because
+// unchanged candidate files are hard links shared with the live Package.
+export async function writeFileDurable(path, data, encoding) {
+  const handle = await open(path, "wx");
+  try {
+    await handle.writeFile(data, encoding);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+
+// Flushes directory entries (creates, renames, unlinks). Some platforms and
+// file systems (notably Windows) cannot open or sync a directory; durability
+// there relies on the file-level syncs alone.
+export async function syncDirectory(path) {
+  let handle;
+  try {
+    handle = await open(path, "r");
+    await handle.sync();
+  } catch (error) {
+    if (
+      !["EISDIR", "EPERM", "EACCES", "EINVAL", "ENOTSUP", "EBADF"].includes(
+        error?.code,
+      )
+    ) {
+      throw error;
+    }
+  } finally {
+    await handle?.close();
+  }
+}

package/src/index.mjs

@@ -3,18 +3,32 @@ export {
   LocalWorkspaceSession,
   reconcilePackageViewState,
 } from "./local-workspace-session.mjs";
-export { openWorkspace, resolveWorkspace } from "./workspace.mjs";
+export {
+  localLibraryLocator,
+  openWorkspace,
+  resolveWorkspace,
+} from "./workspace.mjs";
 export {
   defaultLibraryCacheRoot,
   openRemoteLibrary,
 } from "./remote-library.mjs";
-export { createEvidence, renderProjection } from "./render.mjs";
+export {
+  createEvidence,
+  measureProjectionText,
+  renderProjection,
+} from "./render.mjs";
+export { renderAppProjection } from "./render-shared.mjs";
 export {
   decodeFigmaClipboard,
   importDraft,
   writeDraftPackage,
 } from "./draft-import.mjs";
-export { createBlankPackage, initializeWorkspace } from "./initialize.mjs";
+export {
+  createBlankPackage,
+  initializeBlankWorkspace,
+  initializeWorkspace,
+} from "./initialize.mjs";
+export { migrateThemesByCopy } from "./migrate-themes.mjs";
 export {
   applyOperationBatch,
   deleteFontFamily,
@@ -22,12 +36,14 @@ export {
   importFontVariant,
   importMedia,
   openPackage,
+  readBatchHistory,
   removeMedia,
   replayRecordedBatch,
   updateFontFamily,
 } from "./local-package.mjs";
 export { detectMediaType, inspectMedia } from "./media-inspect.mjs";
 export {
+  fontVariantName,
   inspectFont,
   prepareFontFiles,
   sfntToWoff,