@dirwell/theme-ledger 0.0.0-stage → 0.0.1-alpha

package/dist/source/shared/navigation.mjs

@@ -0,0 +1,294 @@
+// ../core/src/json.ts
+function copyJsonObject(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const copy = (input, depth) => {
+    if (depth > 32) throw new TypeError("Presentation data is too deeply nested");
+    if (input === null || typeof input === "string" || typeof input === "boolean") return input;
+    if (typeof input === "number" && Number.isFinite(input)) return input;
+    if (typeof input !== "object" || input === null || seen.has(input))
+      throw new TypeError("Presentation data must be finite, acyclic JSON");
+    seen.add(input);
+    try {
+      if (Array.isArray(input)) return input.map((item) => copy(item, depth + 1));
+      if (Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null)
+        throw new TypeError("Presentation data must use plain objects");
+      return Object.fromEntries(
+        Object.entries(input).map(([key, item]) => [key, copy(item, depth + 1)])
+      );
+    } finally {
+      seen.delete(input);
+    }
+  };
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new TypeError("Presentation data must be an object");
+  const result = copy(value, 0);
+  if (typeof result !== "object" || result === null || Array.isArray(result))
+    throw new TypeError("Presentation data must be an object");
+  return result;
+}
+
+// ../core/src/client.ts
+var ListingDataError = class extends Error {
+  name = "ListingDataError";
+};
+var StaleListingError = class extends ListingDataError {
+};
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+var kind = (value) => typeof value === "string" && ["directory", "file", "symlink", "other"].includes(value);
+function string(value, name) {
+  if (typeof value !== "string") throw new ListingDataError(`Invalid ${name}`);
+  return value;
+}
+function boolean(value, name) {
+  if (typeof value !== "boolean") throw new ListingDataError(`Invalid ${name}`);
+  return value;
+}
+function href(value, base) {
+  if (value === null) return null;
+  const result = new URL(string(value, "href"), base);
+  if (!["http:", "https:"].includes(result.protocol))
+    throw new ListingDataError("Unsupported listing link protocol");
+  return result.href;
+}
+function entry(value, base) {
+  if (!object(value) || !kind(value.kind) || typeof value.size !== "number" || !Number.isFinite(value.size) || value.size < 0)
+    throw new ListingDataError("Invalid listing entry");
+  let link = null;
+  if (value.link !== null) {
+    if (!object(value.link)) throw new ListingDataError("Invalid link metadata");
+    const targetKind = value.link.targetKind;
+    if (targetKind !== null && (!kind(targetKind) || targetKind === "symlink"))
+      throw new ListingDataError("Invalid target kind");
+    const targetSize = value.link.targetSize;
+    if (targetSize !== null && (typeof targetSize !== "number" || !Number.isFinite(targetSize) || targetSize < 0))
+      throw new ListingDataError("Invalid target size");
+    link = {
+      target: string(value.link.target, "target"),
+      targetKind,
+      targetSize,
+      unavailable: boolean(value.link.unavailable, "unavailable"),
+      cycle: boolean(value.link.cycle, "cycle")
+    };
+  }
+  return {
+    ...value.presentation === void 0 ? {} : { presentation: copyJsonObject(value.presentation) },
+    id: string(value.id, "id"),
+    name: string(value.name, "name"),
+    kind: value.kind,
+    href: href(value.href, base),
+    exitsExplorer: boolean(value.exitsExplorer, "exitsExplorer"),
+    size: value.size,
+    modifiedAt: string(value.modifiedAt, "modifiedAt"),
+    link
+  };
+}
+function manifest(value) {
+  if (!object(value) || value.version !== 1 || !count(value.total) || !Array.isArray(value.blocks) || !object(value.sort))
+    throw new ListingDataError("Invalid listing manifest");
+  const sort = value.sort;
+  if (typeof sort.field !== "string" || !["name", "size", "modified"].includes(sort.field) || typeof sort.direction !== "string" || !["asc", "desc"].includes(sort.direction) || typeof sort.nameMode !== "string" || !["locale", "natural", "unicode"].includes(sort.nameMode) || typeof sort.directoriesFirst !== "boolean")
+    throw new ListingDataError("Invalid listing order");
+  const field = sort.field === "size" ? "size" : sort.field === "modified" ? "modified" : "name";
+  const direction = sort.direction === "desc" ? "desc" : "asc";
+  const nameMode = sort.nameMode === "unicode" ? "unicode" : sort.nameMode === "locale" ? "locale" : "natural";
+  const blocks = value.blocks.map((item) => {
+    if (!object(item) || !count(item.offset) || !count(item.count))
+      throw new ListingDataError("Invalid block descriptor");
+    return { href: string(item.href, "block href"), offset: item.offset, count: item.count };
+  });
+  if (blocks.length === 0) throw new ListingDataError("Missing blocks");
+  return {
+    version: 1,
+    revision: string(value.revision, "revision"),
+    directory: string(value.directory, "directory"),
+    hrefBase: string(value.hrefBase, "href base"),
+    total: value.total,
+    sort: { field, direction, nameMode, directoriesFirst: sort.directoriesFirst },
+    blocks
+  };
+}
+async function loadListing(manifestUrl, options = {}) {
+  const request = options.fetch ?? fetch;
+  const maxEntries = options.maxEntries ?? 1e5;
+  if (!count(maxEntries)) throw new ListingDataError("Invalid entry limit");
+  const source = new URL(manifestUrl);
+  if (!["http:", "https:"].includes(source.protocol))
+    throw new ListingDataError("Listing loading requires HTTP(S); use native file navigation");
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const init = {
+        ...options.signal === void 0 ? {} : { signal: options.signal },
+        cache: attempt === 0 ? options.cache ?? "default" : "reload"
+      };
+      const response = await request(source, init);
+      if (!response.ok) throw new ListingDataError(`Manifest request failed: ${response.status}`);
+      const current = manifest(await response.json());
+      if (current.total > maxEntries)
+        throw new ListingDataError("Listing exceeds the configured entry limit");
+      const base = new URL(current.hrefBase, source);
+      if (!["http:", "https:"].includes(base.protocol))
+        throw new ListingDataError("Unsupported href base protocol");
+      const entries = [];
+      const ids = /* @__PURE__ */ new Set();
+      for (const descriptor of current.blocks) {
+        if (descriptor.offset !== entries.length || descriptor.count + entries.length > current.total)
+          throw new ListingDataError("Invalid block coverage");
+        const blockUrl = new URL(descriptor.href, source);
+        if (blockUrl.origin !== source.origin || !["http:", "https:"].includes(blockUrl.protocol))
+          throw new ListingDataError("Block leaves the manifest origin");
+        const blockResponse = await request(blockUrl, init);
+        if (blockResponse.status === 404 || blockResponse.status === 410)
+          throw new StaleListingError("Block no longer available");
+        if (!blockResponse.ok)
+          throw new ListingDataError(`Block request failed: ${blockResponse.status}`);
+        const data = await blockResponse.json();
+        if (!object(data) || data.version !== 1 || data.revision !== current.revision)
+          throw new StaleListingError("Listing revision changed");
+        if (data.offset !== descriptor.offset || data.total !== current.total || !Array.isArray(data.entries) || data.entries.length !== descriptor.count)
+          throw new ListingDataError("Invalid block envelope");
+        for (const raw of data.entries) {
+          const record = entry(raw, base);
+          if (ids.has(record.id)) throw new ListingDataError("Duplicate entry ID");
+          ids.add(record.id);
+          entries.push(record);
+        }
+      }
+      if (entries.length !== current.total) throw new ListingDataError("Incomplete listing");
+      return { manifest: current, entries };
+    } catch (error) {
+      if (options.signal?.aborted || !(error instanceof StaleListingError) || attempt === 1)
+        throw error;
+    }
+  }
+  throw new ListingDataError("Listing unavailable");
+}
+function parseListingEntries(value, baseHref, maxEntries = 1e5) {
+  if (!Array.isArray(value) || value.length > maxEntries)
+    throw new ListingDataError("Invalid page slice");
+  const base = new URL(baseHref), ids = /* @__PURE__ */ new Set();
+  const result = value.map((raw) => entry(raw, base));
+  for (const record of result) {
+    if (ids.has(record.id)) throw new ListingDataError("Duplicate entry ID");
+    ids.add(record.id);
+  }
+  return result;
+}
+
+// ../shared-theme/src/navigation.ts
+async function fetchThemePage(dataHref, pageHref, theme, signal, fresh = false, attempt = 0) {
+  const source = new URL(dataHref, document.baseURI);
+  if (source.origin !== location.origin)
+    throw new ListingDataError("Folder leaves the theme origin");
+  const response = await fetch(source, { signal, cache: fresh ? "no-store" : "default" });
+  if (!response.ok) throw new ListingDataError("Unavailable folder");
+  const value = await response.json();
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new ListingDataError("Invalid folder snapshot");
+  const data = value;
+  if (data.version !== 1 || data.theme !== theme || typeof data.title !== "string" || typeof data.path !== "string" || !Number.isSafeInteger(data.total) || Number(data.total) < 0 || !Array.isArray(data.breadcrumbs))
+    throw new ListingDataError("Unsupported folder snapshot");
+  if (data.metadataHead !== void 0 && typeof data.metadataHead !== "string")
+    throw new ListingDataError("Invalid folder metadata");
+  const base = document.querySelector("base")?.href ?? pageHref;
+  const link = (raw) => {
+    if (raw === null) return null;
+    if (typeof raw !== "string") throw new ListingDataError("Invalid folder link");
+    const url = new URL(raw, base);
+    if (!["http:", "https:"].includes(url.protocol) || url.origin !== location.origin)
+      throw new ListingDataError("Unsupported folder link");
+    return url.href;
+  };
+  const entries = parseListingEntries(data.entries, base).map((entry2) => ({
+    ...entry2,
+    ...entry2.presentation ? {
+      presentation: {
+        ...entry2.presentation,
+        folderDataHref: link(entry2.presentation.folderDataHref ?? null)
+      }
+    } : {}
+  }));
+  if (entries.length > Number(data.total)) throw new ListingDataError("Invalid folder count");
+  const result = {
+    ...data,
+    updatesHref: link(data.updatesHref ?? null),
+    entries,
+    dataHref: source.href,
+    manifestHref: link(data.manifestHref),
+    rootHref: link(data.rootHref),
+    rootDataHref: link(data.rootDataHref),
+    parentHref: link(data.parentHref),
+    parentDataHref: link(data.parentDataHref),
+    breadcrumbs: data.breadcrumbs.map((raw) => {
+      if (typeof raw !== "object" || raw === null || !("name" in raw) || !("href" in raw) || !("dataHref" in raw) || typeof raw.name !== "string")
+        throw new ListingDataError("Invalid breadcrumb");
+      return { name: raw.name, href: link(raw.href), dataHref: link(raw.dataHref) };
+    })
+  };
+  if (fresh && result.manifestHref) {
+    const loaded = await loadListing(result.manifestHref, { signal, cache: "no-store" });
+    if (loaded.manifest.total !== data.total || data.listingRevision !== void 0 && loaded.manifest.revision !== data.listingRevision) {
+      if (attempt < 2) return fetchThemePage(dataHref, pageHref, theme, signal, true, attempt + 1);
+      throw new ListingDataError("Folder changed while refreshing");
+    }
+    result.entries = [...loaded.entries];
+  }
+  return result;
+}
+var hotModels = /* @__PURE__ */ new WeakMap();
+function restoreThemePage(initial, hot) {
+  if (!hot || typeof document === "undefined") return initial;
+  const root = document.querySelector("[data-dirwell-theme]");
+  if (!root) return initial;
+  const snapshot = hotModels.get(root) ?? initial;
+  hotModels.set(root, snapshot);
+  return snapshot;
+}
+function applyThemeMetadata(page, pageHref) {
+  const root = document.querySelector("[data-dirwell-theme]");
+  if (root && hotModels.has(root)) hotModels.set(root, page);
+  document.title = typeof page.title === "string" ? page.title : "";
+  const template = document.createElement("template");
+  template.innerHTML = typeof page.metadataHead === "string" ? page.metadataHead : "";
+  document.head.querySelectorAll("[data-dirwell-metadata]").forEach((element) => element.remove());
+  const base = document.querySelector("base")?.href ?? pageHref;
+  const url = (value) => {
+    try {
+      const target = new URL(value, base);
+      return ["http:", "https:"].includes(target.protocol) ? target.href : null;
+    } catch {
+      return null;
+    }
+  };
+  for (const element of template.content.children) {
+    if (!element.hasAttribute("data-dirwell-metadata")) continue;
+    let next;
+    if (element.tagName === "META") {
+      const attribute = element.hasAttribute("property") ? "property" : "name";
+      const key = element.getAttribute(attribute) ?? "";
+      if (!/^(?:description|og:[a-z_:]+|twitter:[a-z_:]+)$/i.test(key)) continue;
+      let content = element.getAttribute("content") ?? "";
+      if (["og:image", "og:url", "twitter:image"].includes(key)) {
+        const resolved = url(content);
+        if (resolved === null) continue;
+        content = resolved;
+      }
+      next = document.createElement("meta");
+      next.setAttribute(attribute, key);
+      next.setAttribute("content", content);
+    } else if (element.tagName === "LINK" && element.getAttribute("rel") === "canonical") {
+      const href2 = url(element.getAttribute("href") ?? "");
+      if (href2 === null) continue;
+      next = document.createElement("link");
+      next.setAttribute("rel", "canonical");
+      next.setAttribute("href", href2);
+    } else continue;
+    next.setAttribute("data-dirwell-metadata", "");
+    document.head.append(next);
+  }
+}
+export {
+  applyThemeMetadata,
+  fetchThemePage,
+  restoreThemePage
+};

package/dist/source/shared/records.mjs

@@ -0,0 +1,60 @@
+// ../shared-theme/src/records.ts
+var directoryLike = (entry) => entry.kind === "directory" || entry.link?.targetKind === "directory";
+var entryType = (entry) => entry.kind === "symlink" ? "link" : directoryLike(entry) ? "directory" : "file";
+function fuzzy(query, value) {
+  let score = 0, start = 0, last = -2;
+  for (const character of query.trim().toLocaleLowerCase()) {
+    const index = value.toLocaleLowerCase().indexOf(character, start);
+    if (index < 0) return null;
+    if (index === last + 1) score += 8;
+    if (index === 0 || /[\s/_.-]/.test(value[index - 1] ?? "")) score += 5;
+    score += Math.max(0, 4 - index * 0.05);
+    last = index;
+    start = index + 1;
+  }
+  return score - value.length * 0.01;
+}
+function visibleRecords(entries, query, types, sort) {
+  return entries.map((entry) => ({ entry, score: fuzzy(query, `${entry.name} ${entry.link?.target ?? ""}`) })).filter((item) => types.includes(entryType(item.entry)) && item.score !== null).sort((left, right) => {
+    if (query.trim() && left.score !== right.score) return (right.score ?? 0) - (left.score ?? 0);
+    const a = left.entry, b = right.entry;
+    if (sort.directoriesFirst && directoryLike(a) !== directoryLike(b))
+      return directoryLike(a) ? -1 : 1;
+    const name = () => sort.nameMode === "unicode" ? compareUnicode(a.name, b.name) : a.name.localeCompare(b.name, void 0, {
+      numeric: sort.nameMode === "natural",
+      sensitivity: "base"
+    });
+    const primary = (sort.field === "name" ? name() : sort.field === "size" ? (a.kind === "directory" ? 0 : a.size) - (b.kind === "directory" ? 0 : b.size) : a.modifiedAt.localeCompare(b.modifiedAt)) || name();
+    return (sort.direction === "asc" ? primary : -primary) || compareUnicode(a.id, b.id);
+  }).map((item) => item.entry);
+}
+function compareUnicode(left, right) {
+  const a = [...left], b = [...right];
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    const delta = (a[i]?.codePointAt(0) ?? 0) - (b[i]?.codePointAt(0) ?? 0);
+    if (delta) return delta;
+  }
+  return a.length - b.length;
+}
+function size(bytes) {
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  let value = bytes, index = 0;
+  while (value >= 1024 && index < 4) {
+    value /= 1024;
+    index++;
+  }
+  return `${value.toFixed(index === 0 || value >= 100 ? 0 : 1)} ${units[index]}`;
+}
+function modified(value, local = false) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "Unknown";
+  return local ? date.toLocaleString(void 0, { dateStyle: "short", timeStyle: "short" }) : `${date.toISOString().slice(0, 16).replace("T", " ")} UTC`;
+}
+export {
+  directoryLike,
+  entryType,
+  fuzzy,
+  modified,
+  size,
+  visibleRecords
+};