@publish.os/nextjs 0.0.1-alpha.6 → 0.0.1-alpha.7

package/dist/keyboard-shortcuts.js

@@ -1,6 +1,6 @@
 "use client";
 
-// src/keyboard-shortcuts.tsx
+// src/lib/keyboard/keyboard-shortcuts.tsx
 import {
   createContext,
   use,
@@ -13,23 +13,21 @@ import {
 import { jsx } from "react/jsx-runtime";
 var DEFAULT_OPTIONS = {
   description: "",
-  enabled: true,
-  enableOnContentEditable: false,
-  enableOnFormFields: false,
-  enableWhileComposing: false,
+  enabled: !0,
+  enableOnContentEditable: !1,
+  enableOnFormFields: !1,
+  enableWhileComposing: !1,
   group: "",
-  preventDefault: true,
+  preventDefault: !0,
   priority: 0,
-  stopPropagation: false
-};
-var MODIFIER_TOKENS = /* @__PURE__ */ new Set([
+  stopPropagation: !1
+}, MODIFIER_TOKENS = /* @__PURE__ */ new Set([
   "mod",
   "meta",
   "ctrl",
   "alt",
   "shift"
-]);
-var KEY_ALIASES = {
+]), KEY_ALIASES = {
   cmd: "meta",
   command: "meta",
   control: "ctrl",
@@ -46,9 +44,7 @@ var KEY_ALIASES = {
   space: " ",
   spacebar: " ",
   up: "arrowup"
-};
-var EDITABLE_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
-var SYMBOLS_MAC = {
+}, EDITABLE_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]), SYMBOLS_MAC = {
   " ": "Space",
   alt: "\u2325",
   arrowdown: "\u2193",
@@ -62,8 +58,7 @@ var SYMBOLS_MAC = {
   escape: "\u238B",
   meta: "\u2318",
   shift: "\u21E7"
-};
-var LABELS_OTHER = {
+}, LABELS_OTHER = {
   " ": "Space",
   alt: "Alt",
   arrowdown: "\u2193",
@@ -79,65 +74,53 @@ var LABELS_OTHER = {
   shift: "Shift"
 };
 function platform() {
-  if (typeof navigator === "undefined") return "";
-  return navigator.platform ?? "";
+  return typeof navigator > "u" ? "" : 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) {
+  let source = input.trim(), 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;
+  let alt = !1, ctrl = !1, key = "", meta = !1, shift = !1;
+  for (let part of rawParts) {
+    let aliased = KEY_ALIASES[part] ?? part;
     if (MODIFIER_TOKENS.has(aliased)) {
       switch (aliased) {
         case "mod":
-          if (isMacPlatform()) meta = true;
-          else ctrl = true;
+          isMacPlatform() ? meta = !0 : ctrl = !0;
           break;
         case "meta":
-          meta = true;
+          meta = !0;
           break;
         case "ctrl":
-          ctrl = true;
+          ctrl = !0;
           break;
         case "alt":
-          alt = true;
+          alt = !0;
           break;
         case "shift":
-          shift = true;
+          shift = !0;
           break;
       }
       continue;
     }
-    if (key) {
+    if (key)
       throw new Error(
         `useShortcut: combo "${input}" has more than one non-modifier key`
       );
-    }
     key = aliased;
   }
-  if (!key) {
+  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")) {
+  if (code.length === 4 && code.startsWith("Key"))
     return code[3]?.toLowerCase() ?? null;
-  }
-  if (code.length === 6 && code.startsWith("Digit")) {
+  if (code.length === 6 && code.startsWith("Digit"))
     return code[5] ?? null;
-  }
   switch (code) {
     case "Backquote":
       return "`";
@@ -166,24 +149,19 @@ function codeToLogicalKey(code) {
   }
 }
 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);
+  if (event.metaKey !== chord.meta || event.ctrlKey !== chord.ctrl || event.altKey !== chord.alt)
+    return !1;
+  let keyIsSingleChar = chord.key.length === 1;
+  if (!keyIsSingleChar && event.shiftKey !== chord.shift || keyIsSingleChar && chord.shift && !event.shiftKey) return !1;
+  if (event.key.toLowerCase() === chord.key) return !0;
+  let logicalKey = codeToLogicalKey(event.code);
   return logicalKey !== null && logicalKey === chord.key;
 }
 function inspectTarget(target) {
-  if (!(target instanceof HTMLElement)) {
-    return { isContentEditable: false, isFormField: false };
-  }
-  return {
+  return target instanceof HTMLElement ? {
     isContentEditable: target.isContentEditable,
     isFormField: EDITABLE_TAGS.has(target.tagName)
-  };
+  } : { isContentEditable: !1, isFormField: !1 };
 }
 function resolvedOptions(options) {
   return { ...DEFAULT_OPTIONS, ...options };
@@ -192,28 +170,18 @@ 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();
-      };
-    },
+  let registry = useRef(/* @__PURE__ */ new Map()), ordered = useRef([]), rebuildOrder = useCallback(() => {
+    let next = Array.from(registry.current.values());
+    next.sort((a, b) => b.priority - a.priority), ordered.current = next;
+  }, []), register = useCallback(
+    (registration) => (registry.current.set(registration.id, registration), rebuildOrder(), () => {
+      registry.current.delete(registration.id), rebuildOrder();
+    }),
     [rebuildOrder]
-  );
-  const list = useCallback(() => {
-    const items = [];
-    for (const registration of registry.current.values()) {
-      const { options } = registration.ref.current;
+  ), list = useCallback(() => {
+    let items = [];
+    for (let registration of registry.current.values()) {
+      let { options } = registration.ref.current;
       items.push({
         description: options.description,
         enabled: options.enabled,
@@ -223,100 +191,60 @@ function KeyboardShortcutsProvider({
       });
     }
     return items;
-  }, []);
-  const handleKeyDown = useCallback((event) => {
-    const registrations = ordered.current;
+  }, []), handleKeyDown = useCallback((event) => {
+    let 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) {
+    for (let registration of registrations) {
+      let { handler, options } = registration.ref.current;
+      if (!options.enabled || (event.isComposing || event.keyCode === 229) && !options.enableWhileComposing)
         continue;
-      }
-      let matched = false;
-      for (const chord of registration.chords) {
+      let matched = !1;
+      for (let chord of registration.chords)
         if (chordMatches(event, chord)) {
-          matched = true;
+          matched = !0;
           break;
         }
+      if (matched && (target ??= inspectTarget(event.target), !(target.isFormField && !options.enableOnFormFields) && !(target.isContentEditable && !options.enableOnContentEditable))) {
+        options.preventDefault && event.preventDefault(), options.stopPropagation && event.stopPropagation(), handler(event);
+        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(
+  useEffect(() => (window.addEventListener("keydown", handleKeyDown, { capture: !0 }), () => {
+    window.removeEventListener("keydown", handleKeyDown, { capture: !0 });
+  }), [handleKeyDown]);
+  let api = useMemo(
     () => ({ list, register }),
     [list, register]
   );
   return /* @__PURE__ */ jsx(ShortcutContext, { value: api, children });
 }
 function useShortcut(combo, handler, options) {
-  const api = use(ShortcutContext);
-  if (!api) {
+  let 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({
+  let id = useId(), comboKey = typeof combo == "string" ? combo : combo.join("\0"), chords = useMemo(() => comboKey.split("\0").map(parseChord), [comboKey]), optionsPriority = options?.priority ?? DEFAULT_OPTIONS.priority, 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]);
+  live.current.handler = handler, live.current.options = resolvedOptions(options), useEffect(() => api.register({ chords, id, priority: optionsPriority, ref: live }), [api, chords, id, optionsPriority]);
 }
 function useShortcutRegistry() {
-  const api = use(ShortcutContext);
-  if (!api) {
+  let 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(
+  let chord = parseChord(source), labels = isMacPlatform() ? SYMBOLS_MAC : LABELS_OTHER, tokens = [], push = (name) => tokens.push(labels[name] ?? name);
+  return isMacPlatform() ? (chord.ctrl && push("ctrl"), chord.alt && push("alt"), chord.shift && push("shift"), chord.meta && push("meta")) : (chord.meta && push("meta"), chord.ctrl && push("ctrl"), chord.alt && push("alt"), 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;
+  ), tokens;
 }
 export {
   KeyboardShortcutsProvider,

package/dist/link-CYaCRDb6.d.ts

@@ -0,0 +1,35 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { ReactNode, AnchorHTMLAttributes } from 'react';
+
+declare const buttonVariants: (props?: ({
+    variant?: "solid" | "soft" | "outline" | "ghost" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    iconOnly?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariantProps = VariantProps<typeof buttonVariants>;
+
+declare const linkVariants: (props?: ({
+    color?: "accent" | "default" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    variant?: "inline" | "standalone" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type LinkVariantProps = VariantProps<typeof linkVariants>;
+type LinkStyleVariant = NonNullable<LinkVariantProps["variant"]>;
+type LinkButtonVariant = `button.${NonNullable<ButtonVariantProps["variant"]>}`;
+type LinkVariant = `link.${LinkStyleVariant}` | LinkButtonVariant;
+type NamedLinkColor = "accent" | "default";
+type LinkColor = NamedLinkColor | (string & {});
+type LinkProps = {
+    active?: boolean;
+    children?: ReactNode;
+    color?: LinkColor;
+    disabled?: boolean;
+    href?: string;
+    iconOnly?: ButtonVariantProps["iconOnly"];
+    leftIcon?: ReactNode;
+    rightIcon?: ReactNode;
+    variant?: LinkVariant;
+} & Omit<LinkVariantProps, "color" | "variant"> & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "color" | "href">;
+
+export type { LinkProps as L, LinkStyleVariant as a, LinkButtonVariant as b };

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

@@ -1,11 +1,11 @@
-import react__default from 'react';
-import { ManifestLike, IndexPageProps, LayoutProps, PageProps } from '../types.js';
+import React from 'react';
+import { IndexPageProps, PageProps, ManifestLike, LayoutProps } 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__default.ReactNode): LayoutProps | null;
+declare function resolveGroupLayout(manifest: ManifestLike, group: string, children: React.ReactNode): LayoutProps | null;
 declare function listStaticParams(manifest: ManifestLike, group: string): Array<{
     slug: string[];
 }>;

package/dist/resolvers/manifest-resolver.js

@@ -1,13 +1,12 @@
-// src/resolvers/manifest-resolver.ts
+// src/manifest-resolver.ts
 function findNodeInTree(nodes, id) {
-  for (const node of nodes) {
+  for (let node of nodes) {
     if (node.type === "page") {
       if (node.fileID === id) return node;
-    } else if (node.id === id) {
+    } else if (node.id === id)
       return node;
-    }
     if (node.type === "section" || node.type === "folder") {
-      const found = findNodeInTree(node.children, id);
+      let found = findNodeInTree(node.children, id);
       if (found) return found;
     }
   }
@@ -40,40 +39,35 @@ function groupNode(group) {
   };
 }
 function resolveLeaf(manifest, group, slug) {
-  const slugPath = Array.isArray(slug) ? slug.join("/") : slug;
-  const page = manifest.pages.find((p) => p.group === group && p.slug === slugPath) ?? null;
+  let slugPath = Array.isArray(slug) ? slug.join("/") : slug, page = manifest.pages.find((p) => p.group === group && p.slug === slugPath) ?? null;
   if (!page) return null;
-  const groupData = manifest.groups[group];
-  if (!groupData) return null;
-  return {
+  let groupData = manifest.groups[group];
+  return groupData ? {
     site: manifest.site,
     tree: groupData.tree,
     node: findNodeInTree(groupData.tree, page.fileID) ?? pageNode(page),
     page,
     currentPath: page.path,
     group
-  };
+  } : null;
 }
 function resolveGroup(manifest, group) {
-  const groupData = manifest.groups[group];
-  if (!groupData) return null;
-  return {
+  let groupData = manifest.groups[group];
+  return groupData ? {
     site: manifest.site,
     tree: groupData.tree,
     node: groupNode(groupData),
     currentPath: groupData.path,
     group
-  };
+  } : null;
 }
 function resolveGroupLayout(manifest, group, children) {
-  const resolved = resolveGroup(manifest, group);
-  if (!resolved) return null;
-  return { ...resolved, children };
+  let resolved = resolveGroup(manifest, group);
+  return resolved ? { ...resolved, children } : null;
 }
 function listStaticParams(manifest, group) {
-  const groupData = manifest.groups[group];
-  if (!groupData) return [];
-  return groupData.pages.map((page) => ({ slug: page.slug.split("/") }));
+  let groupData = manifest.groups[group];
+  return groupData ? groupData.pages.map((page) => ({ slug: page.slug.split("/") })) : [];
 }
 export {
   listStaticParams,

package/dist/route-metadata-og-image-BeKKFHg7.d.ts

@@ -0,0 +1,58 @@
+type OgImageEntryLike = {
+    key: string;
+    routePath: string;
+    title: string;
+    description?: string;
+    source: "asset" | "generated" | "remote";
+    url: string;
+    width: number;
+    height: number;
+    alt: string;
+    group?: string;
+    logo?: {
+        dataUri?: string;
+        height?: number;
+        kind: "logo" | "mark" | "wordmark";
+        url: string;
+        width?: number;
+    };
+    siteName?: string;
+    siteUrl?: string;
+    label?: string;
+    background?: string;
+    textPrimary?: string;
+    textSecondary?: string;
+    accent?: string;
+    stroke?: string;
+    theme?: "light" | "dark";
+    fonts?: {
+        main: OgFontRoleLike;
+        mono: OgFontRoleLike;
+    };
+    emoji?: Readonly<Record<string, string>>;
+    fallbackGlyphs?: Partial<Record<"main" | "mono", Readonly<Record<string, string>>>>;
+    fallbackFonts?: ReadonlyArray<{
+        family: string;
+        data: string;
+        style: "normal" | "italic";
+        weight: number;
+    }>;
+};
+type OgManifestLike = {
+    width: number;
+    height: number;
+    generated: Record<string, OgImageEntryLike>;
+};
+type OgFontRoleLike = {
+    family: string;
+    files?: ReadonlyArray<{
+        data: string;
+        path?: string;
+        probe?: string;
+        style: "normal" | "italic";
+        weight: number;
+    }>;
+    sourceType: "google" | "local";
+};
+
+export type { OgManifestLike as O };

package/dist/search.d.ts

@@ -1,7 +1,84 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { SearchBlockVariant, SearchInput, SearchOutput, SearchBlockContextValue } from '@publish.os/nextjs/types';
-export { SearchBlockActions, SearchBlockContextValue, SearchBlockMeta, SearchBlockState, SearchBlockVariant, SearchInput, SearchOutput, SearchResult, SearchStatus, SearchSubResult } from '@publish.os/nextjs/types';
-import { ReactNode } from 'react';
+import { RefObject, ReactNode } from 'react';
+
+type SearchInput = {
+    filters?: {
+        author?: string;
+        group?: string;
+        tag?: string;
+    };
+    limit?: number;
+    offset?: number;
+    q: string;
+};
+type SearchStatus = "idle" | "building" | "stale" | "ready" | "error";
+type SearchSubResult = {
+    excerpt: string;
+    plainExcerpt: string;
+    title: string;
+    url: string;
+};
+type SearchResult = {
+    excerpt: string;
+    id: string;
+    meta: {
+        author?: string;
+        description?: string;
+        group?: string;
+        image?: string;
+        nodeId?: string;
+        path?: string;
+        publishedAt?: string;
+        section?: string;
+        tags?: string;
+        title?: string;
+        updatedAt?: string;
+    };
+    plainExcerpt: string;
+    score?: number;
+    subResults: SearchSubResult[];
+    title: string;
+    url: string;
+};
+type SearchOutput = {
+    items: SearchResult[];
+    message?: string;
+    nextOffset: number | null;
+    status: SearchStatus;
+    total: number;
+};
+type SearchBlockVariant = "desktop" | "mobile";
+type SearchBlockState = {
+    displayResults: SearchResult[];
+    isTyping: boolean;
+    loading: boolean;
+    message?: string;
+    open: boolean;
+    query: string;
+    selectedValue: string;
+    status: SearchStatus;
+    total: number;
+};
+type SearchBlockActions = {
+    handleInputChange(value: string): void;
+    navigateToResult(result: SearchResult): void;
+    setOpen(open: boolean): void;
+    setQuery(value: string): void;
+    setSelectedValue(id: string): void;
+};
+type SearchBlockMeta = {
+    inputId: string;
+    inputRef: RefObject<HTMLInputElement | null>;
+    listId: string;
+    listRef: RefObject<HTMLDivElement | null>;
+    shortcut: string;
+    variant: SearchBlockVariant;
+};
+type SearchBlockContextValue = {
+    actions: SearchBlockActions;
+    meta: SearchBlockMeta;
+    state: SearchBlockState;
+};
 
 declare function search(input: SearchInput): Promise<SearchOutput>;
 declare function useSearch(input: SearchInput): SearchOutput;
@@ -17,4 +94,4 @@ type SearchProviderProps = {
 };
 declare function SearchProvider({ children, defaultOpen, limit, onOpenChange, open: controlledOpen, shortcut, variant, }: SearchProviderProps): react_jsx_runtime.JSX.Element;
 
-export { SearchProvider, type SearchProviderProps, search, useSearch, useSearchBlock };
+export { type SearchBlockActions, type SearchBlockContextValue, type SearchBlockMeta, type SearchBlockState, type SearchBlockVariant, type SearchInput, type SearchOutput, SearchProvider, type SearchProviderProps, type SearchResult, type SearchStatus, type SearchSubResult, search, useSearch, useSearchBlock };