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

package/dist/keyboard-shortcuts.js

@@ -0,0 +1,326 @@
+"use client";
+
+// src/keyboard-shortcuts.tsx
+import {
+  createContext,
+  use,
+  useCallback,
+  useEffect,
+  useId,
+  useMemo,
+  useRef
+} from "react";
+import { jsx } from "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 = createContext(null);
+function KeyboardShortcutsProvider({
+  children
+}) {
+  const registry = useRef(/* @__PURE__ */ new Map());
+  const ordered = useRef([]);
+  const rebuildOrder = useCallback(() => {
+    const next = Array.from(registry.current.values());
+    next.sort((a, b) => b.priority - a.priority);
+    ordered.current = next;
+  }, []);
+  const register = useCallback(
+    (registration) => {
+      registry.current.set(registration.id, registration);
+      rebuildOrder();
+      return () => {
+        registry.current.delete(registration.id);
+        rebuildOrder();
+      };
+    },
+    [rebuildOrder]
+  );
+  const list = 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 = 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;
+    }
+  }, []);
+  useEffect(() => {
+    window.addEventListener("keydown", handleKeyDown, { capture: true });
+    return () => {
+      window.removeEventListener("keydown", handleKeyDown, { capture: true });
+    };
+  }, [handleKeyDown]);
+  const api = useMemo(
+    () => ({ list, register }),
+    [list, register]
+  );
+  return /* @__PURE__ */ jsx(ShortcutContext, { value: api, children });
+}
+function useShortcut(combo, handler, options) {
+  const api = use(ShortcutContext);
+  if (!api) {
+    throw new Error(
+      "useShortcut must be used within <KeyboardShortcutsProvider>."
+    );
+  }
+  const id = useId();
+  const comboKey = typeof combo === "string" ? combo : combo.join("\0");
+  const chords = useMemo(() => {
+    return comboKey.split("\0").map(parseChord);
+  }, [comboKey]);
+  const optionsPriority = options?.priority ?? DEFAULT_OPTIONS.priority;
+  const live = useRef({
+    handler,
+    options: resolvedOptions(options)
+  });
+  live.current.handler = handler;
+  live.current.options = resolvedOptions(options);
+  useEffect(() => {
+    return api.register({ chords, id, priority: optionsPriority, ref: live });
+  }, [api, chords, id, optionsPriority]);
+}
+function useShortcutRegistry() {
+  const api = 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;
+}
+export {
+  KeyboardShortcutsProvider,
+  formatShortcut,
+  useShortcut,
+  useShortcutRegistry
+};

package/dist/resolvers/manifest-resolver.cjs

@@ -28,7 +28,11 @@ __export(manifest_resolver_exports, {
 module.exports = __toCommonJS(manifest_resolver_exports);
 function findNodeInTree(nodes, id) {
   for (const node of nodes) {
-    if (node.id === id) return node;
+    if (node.type === "page") {
+      if (node.fileID === id) return node;
+    } else if (node.id === id) {
+      return node;
+    }
     if (node.type === "section" || node.type === "folder") {
       const found = findNodeInTree(node.children, id);
       if (found) return found;
@@ -39,7 +43,7 @@ function findNodeInTree(nodes, id) {
 function pageNode(page) {
   return {
     type: "page",
-    id: page.id,
+    fileID: page.fileID,
     title: page.title,
     path: page.path,
     group: page.group,
@@ -71,7 +75,7 @@ function resolveLeaf(manifest, group, slug) {
   return {
     site: manifest.site,
     tree: groupData.tree,
-    node: findNodeInTree(groupData.tree, page.id) ?? pageNode(page),
+    node: findNodeInTree(groupData.tree, page.fileID) ?? pageNode(page),
     page,
     currentPath: page.path,
     group

package/dist/resolvers/manifest-resolver.d.cts

@@ -1,11 +1,11 @@
-import React from 'react';
+import react__default from 'react';
 import { ManifestLike, IndexPageProps, LayoutProps, PageProps } from '../types.cjs';
 
 type ResolvedLeaf = PageProps;
 type ResolvedGroup = Omit<IndexPageProps, "children">;
 declare function resolveLeaf(manifest: ManifestLike, group: string, slug: string | string[]): ResolvedLeaf | null;
 declare function resolveGroup(manifest: ManifestLike, group: string): ResolvedGroup | null;
-declare function resolveGroupLayout(manifest: ManifestLike, group: string, children: React.ReactNode): LayoutProps | null;
+declare function resolveGroupLayout(manifest: ManifestLike, group: string, children: react__default.ReactNode): LayoutProps | null;
 declare function listStaticParams(manifest: ManifestLike, group: string): Array<{
     slug: string[];
 }>;

package/dist/resolvers/manifest-resolver.d.ts

@@ -1,11 +1,11 @@
-import React from 'react';
+import react__default from 'react';
 import { ManifestLike, IndexPageProps, LayoutProps, PageProps } from '../types.js';
 
 type ResolvedLeaf = PageProps;
 type ResolvedGroup = Omit<IndexPageProps, "children">;
 declare function resolveLeaf(manifest: ManifestLike, group: string, slug: string | string[]): ResolvedLeaf | null;
 declare function resolveGroup(manifest: ManifestLike, group: string): ResolvedGroup | null;
-declare function resolveGroupLayout(manifest: ManifestLike, group: string, children: React.ReactNode): LayoutProps | null;
+declare function resolveGroupLayout(manifest: ManifestLike, group: string, children: react__default.ReactNode): LayoutProps | null;
 declare function listStaticParams(manifest: ManifestLike, group: string): Array<{
     slug: string[];
 }>;

package/dist/resolvers/manifest-resolver.js

@@ -1,7 +1,11 @@
 // src/resolvers/manifest-resolver.ts
 function findNodeInTree(nodes, id) {
   for (const node of nodes) {
-    if (node.id === id) return node;
+    if (node.type === "page") {
+      if (node.fileID === id) return node;
+    } else if (node.id === id) {
+      return node;
+    }
     if (node.type === "section" || node.type === "folder") {
       const found = findNodeInTree(node.children, id);
       if (found) return found;
@@ -12,7 +16,7 @@ function findNodeInTree(nodes, id) {
 function pageNode(page) {
   return {
     type: "page",
-    id: page.id,
+    fileID: page.fileID,
     title: page.title,
     path: page.path,
     group: page.group,
@@ -44,7 +48,7 @@ function resolveLeaf(manifest, group, slug) {
   return {
     site: manifest.site,
     tree: groupData.tree,
-    node: findNodeInTree(groupData.tree, page.id) ?? pageNode(page),
+    node: findNodeInTree(groupData.tree, page.fileID) ?? pageNode(page),
     page,
     currentPath: page.path,
     group