@publish.os/nextjs 0.0.1-alpha.2 → 0.0.1-alpha.4

package/dist/kernel/routes/pages/root.js

@@ -0,0 +1,203 @@
+// src/kernel/routes/pages/root.tsx
+import { cacheLife, cacheTag } from "next/cache";
+
+// src/cache/tags.ts
+import { createHash } from "crypto";
+var MAX_TAG_LEN = 256;
+var MAX_SEGMENT_LEN = 80;
+var TAG_PATTERN = /^[a-z0-9:_./-]+$/;
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+function safeSegment(value) {
+  const raw = value.trim().toLowerCase() || "root";
+  const normalized = raw.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "").replace(/[^a-z0-9:_./-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const segment = normalized || "root";
+  if (segment.length <= MAX_SEGMENT_LEN) return segment;
+  return `${segment.slice(0, 48)}.${sha256(segment)}`;
+}
+function assertTag(tag) {
+  if (tag.length > MAX_TAG_LEN || !TAG_PATTERN.test(tag)) {
+    return `tag:${sha256(tag)}`;
+  }
+  return tag;
+}
+var tags = {
+  site() {
+    return "site";
+  },
+  pages() {
+    return "pages";
+  },
+  group(group) {
+    return assertTag(`group:${safeSegment(group)}`);
+  },
+  page(group, slug) {
+    const path = Array.isArray(slug) ? slug.join("/") : slug;
+    return assertTag(`page:${safeSegment(group)}:${safeSegment(path)}`);
+  },
+  manifest(contentHash) {
+    return assertTag(`manifest:${safeSegment(contentHash)}`);
+  },
+  sitemap() {
+    return "sitemap";
+  },
+  robots() {
+    return "robots";
+  },
+  llms(scope = "root") {
+    return assertTag(`llms:${safeSegment(scope)}`);
+  },
+  feed(format, scope = "site") {
+    return assertTag(`feed:${safeSegment(format)}:${safeSegment(scope)}`);
+  }
+};
+
+// src/internal/utils/logger.ts
+var isDev = process.env.NODE_ENV !== "production";
+var isDebugEnabled = process.env.NEXT_PRIVATE_DEBUG_CACHE === "1";
+var log = {
+  debug(...args) {
+    if (isDev && isDebugEnabled) console.debug("[publish.os:debug]", ...args);
+  },
+  info(...args) {
+    console.log("[publish.os]", ...args);
+  },
+  warn(...args) {
+    console.warn("[publish.os:warn]", ...args);
+  },
+  error(...args) {
+    console.error("[publish.os:error]", ...args);
+  }
+};
+
+// src/kernel/routes/pages/agent-metadata.ts
+function normalizePath(path) {
+  const prefixed = path.startsWith("/") ? path : `/${path}`;
+  if (prefixed === "/") return prefixed;
+  return prefixed.replace(/\/+$/, "");
+}
+function agentReadableAlternates({
+  canonicalPath,
+  manifest,
+  markdownPath
+}) {
+  return {
+    ...manifest.site.url ? { canonical: normalizePath(canonicalPath) } : {},
+    types: {
+      ...markdownPath ? { "text/markdown": normalizePath(markdownPath) } : {},
+      "text/plain": "/llms.txt"
+    }
+  };
+}
+
+// src/kernel/routes/pages/social-metadata.ts
+function isDevelopment() {
+  return process.env.NODE_ENV === "development";
+}
+function absoluteUrl(path, siteUrl) {
+  if (/^https:\/\//.test(path)) return path;
+  if (isDevelopment()) return path;
+  if (!siteUrl) return path;
+  return new URL(path, siteUrl).toString();
+}
+function createSocialMetadata({
+  canonicalPath,
+  description,
+  manifest,
+  ogManifest,
+  title,
+  type = "website"
+}) {
+  const key = ogManifest?.routes?.[canonicalPath];
+  const rootKey = ogManifest?.routes?.["/"];
+  const entry = (key ? ogManifest?.entries?.[key] : void 0) ?? (rootKey ? ogManifest?.entries?.[rootKey] : void 0);
+  if (!entry) {
+    return {
+      openGraph: {
+        description,
+        title,
+        type,
+        url: canonicalPath
+      },
+      twitter: {
+        card: "summary",
+        description,
+        title
+      }
+    };
+  }
+  const imageUrl = absoluteUrl(entry.url, manifest.site.url);
+  return {
+    openGraph: {
+      description,
+      images: [
+        {
+          alt: entry.alt,
+          height: entry.height,
+          url: imageUrl,
+          width: entry.width
+        }
+      ],
+      siteName: manifest.site.name,
+      title,
+      type,
+      url: canonicalPath
+    },
+    twitter: {
+      card: "summary_large_image",
+      description,
+      images: [imageUrl],
+      title
+    }
+  };
+}
+
+// src/kernel/routes/pages/root.tsx
+import { jsx } from "react/jsx-runtime";
+var rootManifest;
+var rootPage;
+async function CachedRootPage() {
+  "use cache";
+  cacheLife("page");
+  cacheTag(tags.site());
+  if (!rootManifest || !rootPage) return null;
+  cacheTag(tags.manifest(rootManifest.contentHash));
+  log.debug("[cache]", "root");
+  const RootPage = rootPage;
+  return /* @__PURE__ */ jsx(RootPage, { site: rootManifest.site, tree: rootManifest.tree });
+}
+function createRootPage({ manifest, RootPage }) {
+  rootManifest = manifest;
+  rootPage = RootPage;
+  return async function Page() {
+    log.debug("[render]", "root");
+    return /* @__PURE__ */ jsx(CachedRootPage, {});
+  };
+}
+function createRootMetadata({
+  manifest,
+  ogManifest
+}) {
+  const description = manifest.site.description;
+  return {
+    title: manifest.site.name,
+    description,
+    alternates: agentReadableAlternates({
+      canonicalPath: "/",
+      manifest,
+      markdownPath: "/sitemap.md"
+    }),
+    ...createSocialMetadata({
+      canonicalPath: "/",
+      description,
+      manifest,
+      ogManifest,
+      title: manifest.site.name
+    })
+  };
+}
+export {
+  createRootMetadata,
+  createRootPage
+};

package/dist/keyboard-shortcuts.cjs

@@ -0,0 +1,345 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/keyboard-shortcuts.tsx
+var keyboard_shortcuts_exports = {};
+__export(keyboard_shortcuts_exports, {
+  KeyboardShortcutsProvider: () => KeyboardShortcutsProvider,
+  formatShortcut: () => formatShortcut,
+  useShortcut: () => useShortcut,
+  useShortcutRegistry: () => useShortcutRegistry
+});
+module.exports = __toCommonJS(keyboard_shortcuts_exports);
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var DEFAULT_OPTIONS = {
+  description: "",
+  enabled: true,
+  enableOnContentEditable: false,
+  enableOnFormFields: false,
+  enableWhileComposing: false,
+  group: "",
+  preventDefault: true,
+  priority: 0,
+  stopPropagation: false
+};
+var MODIFIER_TOKENS = /* @__PURE__ */ new Set([
+  "mod",
+  "meta",
+  "ctrl",
+  "alt",
+  "shift"
+]);
+var KEY_ALIASES = {
+  cmd: "meta",
+  command: "meta",
+  control: "ctrl",
+  del: "delete",
+  down: "arrowdown",
+  esc: "escape",
+  ins: "insert",
+  left: "arrowleft",
+  opt: "alt",
+  option: "alt",
+  plus: "+",
+  return: "enter",
+  right: "arrowright",
+  space: " ",
+  spacebar: " ",
+  up: "arrowup"
+};
+var EDITABLE_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
+var SYMBOLS_MAC = {
+  " ": "Space",
+  alt: "\u2325",
+  arrowdown: "\u2193",
+  arrowleft: "\u2190",
+  arrowright: "\u2192",
+  arrowup: "\u2191",
+  backspace: "\u232B",
+  ctrl: "\u2303",
+  delete: "\u2326",
+  enter: "\u21B5",
+  escape: "\u238B",
+  meta: "\u2318",
+  shift: "\u21E7"
+};
+var LABELS_OTHER = {
+  " ": "Space",
+  alt: "Alt",
+  arrowdown: "\u2193",
+  arrowleft: "\u2190",
+  arrowright: "\u2192",
+  arrowup: "\u2191",
+  backspace: "Backspace",
+  ctrl: "Ctrl",
+  delete: "Delete",
+  enter: "Enter",
+  escape: "Esc",
+  meta: "Win",
+  shift: "Shift"
+};
+function platform() {
+  if (typeof navigator === "undefined") return "";
+  return navigator.platform ?? "";
+}
+function isMacPlatform() {
+  return /mac|iphone|ipad|ipod/i.test(platform());
+}
+function parseChord(input) {
+  const source = input.trim();
+  const rawParts = source.split("+").map((part) => part.trim().toLowerCase()).filter(Boolean);
+  if (rawParts.length === 0) {
+    throw new Error(`useShortcut: empty key combo "${input}"`);
+  }
+  let alt = false;
+  let ctrl = false;
+  let key = "";
+  let meta = false;
+  let shift = false;
+  for (const part of rawParts) {
+    const aliased = KEY_ALIASES[part] ?? part;
+    if (MODIFIER_TOKENS.has(aliased)) {
+      switch (aliased) {
+        case "mod":
+          if (isMacPlatform()) meta = true;
+          else ctrl = true;
+          break;
+        case "meta":
+          meta = true;
+          break;
+        case "ctrl":
+          ctrl = true;
+          break;
+        case "alt":
+          alt = true;
+          break;
+        case "shift":
+          shift = true;
+          break;
+      }
+      continue;
+    }
+    if (key) {
+      throw new Error(
+        `useShortcut: combo "${input}" has more than one non-modifier key`
+      );
+    }
+    key = aliased;
+  }
+  if (!key) {
+    throw new Error(`useShortcut: combo "${input}" has no non-modifier key`);
+  }
+  return { alt, ctrl, key, meta, shift, source };
+}
+function codeToLogicalKey(code) {
+  if (code.length === 4 && code.startsWith("Key")) {
+    return code[3]?.toLowerCase() ?? null;
+  }
+  if (code.length === 6 && code.startsWith("Digit")) {
+    return code[5] ?? null;
+  }
+  switch (code) {
+    case "Backquote":
+      return "`";
+    case "Backslash":
+      return "\\";
+    case "BracketLeft":
+      return "[";
+    case "BracketRight":
+      return "]";
+    case "Comma":
+      return ",";
+    case "Equal":
+      return "=";
+    case "Minus":
+      return "-";
+    case "Period":
+      return ".";
+    case "Quote":
+      return "'";
+    case "Semicolon":
+      return ";";
+    case "Slash":
+      return "/";
+    default:
+      return null;
+  }
+}
+function chordMatches(event, chord) {
+  if (event.metaKey !== chord.meta || event.ctrlKey !== chord.ctrl || event.altKey !== chord.alt) {
+    return false;
+  }
+  const keyIsSingleChar = chord.key.length === 1;
+  if (!keyIsSingleChar && event.shiftKey !== chord.shift) return false;
+  if (keyIsSingleChar && chord.shift && !event.shiftKey) return false;
+  if (event.key.toLowerCase() === chord.key) return true;
+  const logicalKey = codeToLogicalKey(event.code);
+  return logicalKey !== null && logicalKey === chord.key;
+}
+function inspectTarget(target) {
+  if (!(target instanceof HTMLElement)) {
+    return { isContentEditable: false, isFormField: false };
+  }
+  return {
+    isContentEditable: target.isContentEditable,
+    isFormField: EDITABLE_TAGS.has(target.tagName)
+  };
+}
+function resolvedOptions(options) {
+  return { ...DEFAULT_OPTIONS, ...options };
+}
+var ShortcutContext = (0, import_react.createContext)(null);
+function KeyboardShortcutsProvider({
+  children
+}) {
+  const registry = (0, import_react.useRef)(/* @__PURE__ */ new Map());
+  const ordered = (0, import_react.useRef)([]);
+  const rebuildOrder = (0, import_react.useCallback)(() => {
+    const next = Array.from(registry.current.values());
+    next.sort((a, b) => b.priority - a.priority);
+    ordered.current = next;
+  }, []);
+  const register = (0, import_react.useCallback)(
+    (registration) => {
+      registry.current.set(registration.id, registration);
+      rebuildOrder();
+      return () => {
+        registry.current.delete(registration.id);
+        rebuildOrder();
+      };
+    },
+    [rebuildOrder]
+  );
+  const list = (0, import_react.useCallback)(() => {
+    const items = [];
+    for (const registration of registry.current.values()) {
+      const { options } = registration.ref.current;
+      items.push({
+        description: options.description,
+        enabled: options.enabled,
+        group: options.group,
+        id: registration.id,
+        source: registration.chords.map((chord) => chord.source)
+      });
+    }
+    return items;
+  }, []);
+  const handleKeyDown = (0, import_react.useCallback)((event) => {
+    const registrations = ordered.current;
+    if (registrations.length === 0) return;
+    let target = null;
+    for (const registration of registrations) {
+      const { handler, options } = registration.ref.current;
+      if (!options.enabled) continue;
+      if ((event.isComposing || event.keyCode === 229) && !options.enableWhileComposing) {
+        continue;
+      }
+      let matched = false;
+      for (const chord of registration.chords) {
+        if (chordMatches(event, chord)) {
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) continue;
+      target ??= inspectTarget(event.target);
+      if (target.isFormField && !options.enableOnFormFields) continue;
+      if (target.isContentEditable && !options.enableOnContentEditable) {
+        continue;
+      }
+      if (options.preventDefault) event.preventDefault();
+      if (options.stopPropagation) event.stopPropagation();
+      handler(event);
+      break;
+    }
+  }, []);
+  (0, import_react.useEffect)(() => {
+    window.addEventListener("keydown", handleKeyDown, { capture: true });
+    return () => {
+      window.removeEventListener("keydown", handleKeyDown, { capture: true });
+    };
+  }, [handleKeyDown]);
+  const api = (0, import_react.useMemo)(
+    () => ({ list, register }),
+    [list, register]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ShortcutContext, { value: api, children });
+}
+function useShortcut(combo, handler, options) {
+  const api = (0, import_react.use)(ShortcutContext);
+  if (!api) {
+    throw new Error(
+      "useShortcut must be used within <KeyboardShortcutsProvider>."
+    );
+  }
+  const id = (0, import_react.useId)();
+  const comboKey = typeof combo === "string" ? combo : combo.join("\0");
+  const chords = (0, import_react.useMemo)(() => {
+    return comboKey.split("\0").map(parseChord);
+  }, [comboKey]);
+  const optionsPriority = options?.priority ?? DEFAULT_OPTIONS.priority;
+  const live = (0, import_react.useRef)({
+    handler,
+    options: resolvedOptions(options)
+  });
+  live.current.handler = handler;
+  live.current.options = resolvedOptions(options);
+  (0, import_react.useEffect)(() => {
+    return api.register({ chords, id, priority: optionsPriority, ref: live });
+  }, [api, chords, id, optionsPriority]);
+}
+function useShortcutRegistry() {
+  const api = (0, import_react.use)(ShortcutContext);
+  if (!api) {
+    throw new Error(
+      "useShortcutRegistry must be used within <KeyboardShortcutsProvider>."
+    );
+  }
+  return { list: api.list };
+}
+function formatShortcut(source) {
+  const chord = parseChord(source);
+  const labels = isMacPlatform() ? SYMBOLS_MAC : LABELS_OTHER;
+  const tokens = [];
+  const push = (name) => tokens.push(labels[name] ?? name);
+  if (isMacPlatform()) {
+    if (chord.ctrl) push("ctrl");
+    if (chord.alt) push("alt");
+    if (chord.shift) push("shift");
+    if (chord.meta) push("meta");
+  } else {
+    if (chord.meta) push("meta");
+    if (chord.ctrl) push("ctrl");
+    if (chord.alt) push("alt");
+    if (chord.shift) push("shift");
+  }
+  tokens.push(
+    labels[chord.key] ?? (chord.key.length === 1 ? chord.key.toUpperCase() : chord.key.replace(/^\w/, (character) => character.toUpperCase()))
+  );
+  return tokens;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KeyboardShortcutsProvider,
+  formatShortcut,
+  useShortcut,
+  useShortcutRegistry
+});

package/dist/keyboard-shortcuts.d.cts

@@ -0,0 +1,34 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+type Modifier = "mod" | "meta" | "ctrl" | "alt" | "shift";
+type ShortcutHandler = (event: KeyboardEvent) => void;
+interface ShortcutOptions {
+    description?: string;
+    enabled?: boolean;
+    enableOnContentEditable?: boolean;
+    enableOnFormFields?: boolean;
+    enableWhileComposing?: boolean;
+    group?: string;
+    preventDefault?: boolean;
+    priority?: number;
+    stopPropagation?: boolean;
+}
+type ShortcutRegistryItem = {
+    description: string;
+    enabled: boolean;
+    group: string;
+    id: string;
+    source: string[];
+};
+type ShortcutRegistryApi = {
+    list: () => readonly ShortcutRegistryItem[];
+};
+declare function KeyboardShortcutsProvider({ children, }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useShortcut(combo: string | readonly string[], handler: ShortcutHandler, options?: ShortcutOptions): void;
+declare function useShortcutRegistry(): ShortcutRegistryApi;
+declare function formatShortcut(source: string): string[];
+
+export { KeyboardShortcutsProvider, type Modifier, type ShortcutHandler, type ShortcutOptions, type ShortcutRegistryApi, type ShortcutRegistryItem, formatShortcut, useShortcut, useShortcutRegistry };

package/dist/keyboard-shortcuts.d.ts

@@ -0,0 +1,34 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+type Modifier = "mod" | "meta" | "ctrl" | "alt" | "shift";
+type ShortcutHandler = (event: KeyboardEvent) => void;
+interface ShortcutOptions {
+    description?: string;
+    enabled?: boolean;
+    enableOnContentEditable?: boolean;
+    enableOnFormFields?: boolean;
+    enableWhileComposing?: boolean;
+    group?: string;
+    preventDefault?: boolean;
+    priority?: number;
+    stopPropagation?: boolean;
+}
+type ShortcutRegistryItem = {
+    description: string;
+    enabled: boolean;
+    group: string;
+    id: string;
+    source: string[];
+};
+type ShortcutRegistryApi = {
+    list: () => readonly ShortcutRegistryItem[];
+};
+declare function KeyboardShortcutsProvider({ children, }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useShortcut(combo: string | readonly string[], handler: ShortcutHandler, options?: ShortcutOptions): void;
+declare function useShortcutRegistry(): ShortcutRegistryApi;
+declare function formatShortcut(source: string): string[];
+
+export { KeyboardShortcutsProvider, type Modifier, type ShortcutHandler, type ShortcutOptions, type ShortcutRegistryApi, type ShortcutRegistryItem, formatShortcut, useShortcut, useShortcutRegistry };