@lukoweb/apitogo 0.1.24 → 0.1.37

package/src/lib/hooks/useEvent.ts

@@ -1,41 +1,41 @@
-import { useEffect, useState } from "react";
-import { useApitogo } from "../components/context/ZudokuContext.js";
-import type { ApitogoEvents } from "../core/ZudokuContext.js";
-
-type EventParameters<Event extends keyof ApitogoEvents> = Parameters<
-  ApitogoEvents[Event]
->;
-
-/**
- * Hook to subscribe to APIToGo application events with automatic cleanup
- * @param event The event to subscribe to
- * @param callback Optional callback to be called when the event is emitted
- * @returns The latest event data if no callback is provided, or the callback's return value if it returns something
- */
-export function useEvent<E extends keyof ApitogoEvents>(
-  event: E,
-): EventParameters<E>;
-export function useEvent<E extends keyof ApitogoEvents, R>(
-  event: E,
-  callback: (...args: EventParameters<E>) => R,
-): R;
-export function useEvent<E extends keyof ApitogoEvents, R>(
-  event: E,
-  callback?: (...args: EventParameters<E>) => R,
-) {
-  const apitogo = useApitogo();
-  const [latestData, setLatestData] = useState<R | EventParameters<E>>();
-
-  useEffect(() => {
-    return apitogo.addEventListener(event, ((...args: EventParameters<E>) => {
-      if (callback) {
-        const result = callback(...args);
-        setLatestData(result);
-      } else {
-        setLatestData(args);
-      }
-    }) as ApitogoEvents[E]);
-  }, [apitogo, event, callback]);
-
-  return latestData;
-}
+import { useEffect, useState } from "react";
+import { useApitogo } from "../components/context/ZudokuContext.js";
+import type { ApitogoEvents } from "../core/ZudokuContext.js";
+
+type EventParameters<Event extends keyof ApitogoEvents> = Parameters<
+  ApitogoEvents[Event]
+>;
+
+/**
+ * Hook to subscribe to APIToGo application events with automatic cleanup
+ * @param event The event to subscribe to
+ * @param callback Optional callback to be called when the event is emitted
+ * @returns The latest event data if no callback is provided, or the callback's return value if it returns something
+ */
+export function useEvent<E extends keyof ApitogoEvents>(
+  event: E,
+): EventParameters<E>;
+export function useEvent<E extends keyof ApitogoEvents, R>(
+  event: E,
+  callback: (...args: EventParameters<E>) => R,
+): R;
+export function useEvent<E extends keyof ApitogoEvents, R>(
+  event: E,
+  callback?: (...args: EventParameters<E>) => R,
+) {
+  const apitogo = useApitogo();
+  const [latestData, setLatestData] = useState<R | EventParameters<E>>();
+
+  useEffect(() => {
+    return apitogo.addEventListener(event, ((...args: EventParameters<E>) => {
+      if (callback) {
+        const result = callback(...args);
+        setLatestData(result);
+      } else {
+        setLatestData(args);
+      }
+    }) as ApitogoEvents[E]);
+  }, [apitogo, event, callback]);
+
+  return latestData;
+}

package/src/lib/hooks/useHighlighter.ts

@@ -1,15 +1,15 @@
-import { use } from "react";
-import type { HighlighterCore } from "shiki";
-import { useZudoku } from "../components/context/ZudokuContext.js";
-
-export const useHighlighter = (): HighlighterCore => {
-  const { syntaxHighlighting } = useZudoku().options;
-
-  if (!syntaxHighlighting) {
-    throw new Error(
-      "Syntax highlighting not configured. Provide highlighterPromise in syntaxHighlighting options.",
-    );
-  }
-
-  return use(syntaxHighlighting.highlighterPromise);
-};
+import { use } from "react";
+import type { HighlighterCore } from "shiki";
+import { useZudoku } from "../components/context/ZudokuContext.js";
+
+export const useHighlighter = (): HighlighterCore => {
+  const { syntaxHighlighting } = useZudoku().options;
+
+  if (!syntaxHighlighting) {
+    throw new Error(
+      "Syntax highlighting not configured. Provide highlighterPromise in syntaxHighlighting options.",
+    );
+  }
+
+  return use(syntaxHighlighting.highlighterPromise);
+};

package/src/lib/hooks/useHotkey.ts

@@ -1,70 +1,70 @@
-import { useEffect, useRef } from "react";
-import { isAppleDevice } from "../util/os.js";
-
-const keymap = {
-  other: {
-    alt: "Alt",
-    meta: "Ctrl",
-    ctrl: "Ctrl",
-    shift: "⇧",
-    option: "Alt",
-  },
-  apple: {
-    alt: "⌥",
-    meta: "⌘",
-    ctrl: "Ctrl",
-    shift: "⇧",
-    option: "⌥",
-  },
-};
-
-export const useHotkey = (hotkey: string, callback: () => void) => {
-  const hotkeySanitized = hotkey.toLowerCase().split("+");
-  const meta = hotkeySanitized.includes("meta");
-  const shift = hotkeySanitized.includes("shift");
-  const alt =
-    hotkeySanitized.includes("option") || hotkeySanitized.includes("alt");
-  const ctrl = hotkeySanitized.includes("ctrl");
-
-  const key = hotkey.split("+").pop();
-
-  const callbackRef = useRef(callback);
-
-  useEffect(() => {
-    callbackRef.current = callback;
-  }, [callback]);
-
-  useEffect(() => {
-    const handler = (event: KeyboardEvent) => {
-      if (
-        (event.code === `Key${key?.toUpperCase()}` ||
-          event.code.toLowerCase() === key?.toLowerCase()) &&
-        event.metaKey === meta &&
-        event.shiftKey === shift &&
-        event.altKey === alt &&
-        event.ctrlKey === ctrl
-      ) {
-        event.preventDefault();
-        callbackRef.current();
-      }
-    };
-
-    window.addEventListener("keydown", handler);
-    return () => {
-      window.removeEventListener("keydown", handler);
-    };
-  }, [key, meta, shift, alt, ctrl]);
-
-  return {
-    trigger: () => callbackRef.current(),
-    label: hotkeySanitized.map((key: string) =>
-      key === "meta" ||
-      key === "ctrl" ||
-      key === "alt" ||
-      key === "shift" ||
-      key === "option"
-        ? keymap[isAppleDevice() ? "apple" : "other"][key]
-        : key,
-    ),
-  };
-};
+import { useEffect, useRef } from "react";
+import { isAppleDevice } from "../util/os.js";
+
+const keymap = {
+  other: {
+    alt: "Alt",
+    meta: "Ctrl",
+    ctrl: "Ctrl",
+    shift: "⇧",
+    option: "Alt",
+  },
+  apple: {
+    alt: "⌥",
+    meta: "⌘",
+    ctrl: "Ctrl",
+    shift: "⇧",
+    option: "⌥",
+  },
+};
+
+export const useHotkey = (hotkey: string, callback: () => void) => {
+  const hotkeySanitized = hotkey.toLowerCase().split("+");
+  const meta = hotkeySanitized.includes("meta");
+  const shift = hotkeySanitized.includes("shift");
+  const alt =
+    hotkeySanitized.includes("option") || hotkeySanitized.includes("alt");
+  const ctrl = hotkeySanitized.includes("ctrl");
+
+  const key = hotkey.split("+").pop();
+
+  const callbackRef = useRef(callback);
+
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+
+  useEffect(() => {
+    const handler = (event: KeyboardEvent) => {
+      if (
+        (event.code === `Key${key?.toUpperCase()}` ||
+          event.code.toLowerCase() === key?.toLowerCase()) &&
+        event.metaKey === meta &&
+        event.shiftKey === shift &&
+        event.altKey === alt &&
+        event.ctrlKey === ctrl
+      ) {
+        event.preventDefault();
+        callbackRef.current();
+      }
+    };
+
+    window.addEventListener("keydown", handler);
+    return () => {
+      window.removeEventListener("keydown", handler);
+    };
+  }, [key, meta, shift, alt, ctrl]);
+
+  return {
+    trigger: () => callbackRef.current(),
+    label: hotkeySanitized.map((key: string) =>
+      key === "meta" ||
+      key === "ctrl" ||
+      key === "alt" ||
+      key === "shift" ||
+      key === "option"
+        ? keymap[isAppleDevice() ? "apple" : "other"][key]
+        : key,
+    ),
+  };
+};

package/src/lib/icons.ts

@@ -1,2 +1,2 @@
-export * from "lucide-react";
-export * from "./MissingIcon.js";
+export * from "lucide-react";
+export * from "./MissingIcon.js";

package/src/lib/navigation/applyRules.ts

@@ -1,127 +1,127 @@
-import type {
-  NavigationItem,
-  ResolvedNavigationRule,
-  SortableNavigationItem,
-} from "../../config/validators/NavigationSchema.js";
-import { findByPath } from "./pathMatcher.js";
-
-export const SORTABLE_TYPES = ["doc", "link", "category", "section"] as const;
-export type SortableType = (typeof SORTABLE_TYPES)[number];
-
-const isSortable = (item: NavigationItem): item is SortableNavigationItem =>
-  SORTABLE_TYPES.some((t) => t === item.type);
-
-export type ApplyRulesResult = {
-  result: NavigationItem[];
-  warnings: string[];
-};
-
-const cloneNavigation = (items: NavigationItem[]): NavigationItem[] =>
-  items.map((item) =>
-    item.type === "category"
-      ? { ...item, items: cloneNavigation(item.items) }
-      : { ...item },
-  );
-
-// Strips the top-nav prefix from a rule path if it matches the current label.
-const normalizeRulePath = (rulePath: string, topNavLabel?: string) => {
-  if (!topNavLabel) return rulePath;
-
-  const segments = rulePath.split("/").filter(Boolean);
-  const first = segments[0];
-  if (!first) return rulePath;
-
-  // Number segments can't match a top-nav label
-  if (!Number.isNaN(Number(first))) {
-    return segments.length > 1 ? undefined : rulePath;
-  }
-
-  if (first.toLowerCase() === topNavLabel.toLowerCase()) {
-    const rest = segments.slice(1).join("/");
-    return rest || "/";
-  }
-
-  // Multi-segment path where first segment doesn't match → different context
-  if (segments.length > 1) return undefined;
-
-  // Single segment: apply to sidebar as-is
-  return rulePath;
-};
-
-export const applyRules = (
-  navigation: NavigationItem[],
-  rules: ResolvedNavigationRule[],
-  topNavLabel?: string,
-): ApplyRulesResult => {
-  const result = cloneNavigation(navigation);
-  const warnings: string[] = [];
-
-  for (const rule of rules) {
-    const normalizedPath = normalizeRulePath(rule.match, topNavLabel);
-    if (normalizedPath === undefined) continue;
-
-    const match = findByPath(result, normalizedPath);
-    if (!match) {
-      warnings.push(`Rule target "${rule.match}" not found`);
-      continue;
-    }
-
-    if (match.isRoot) {
-      if (rule.type === "sort") {
-        result.sort((a, b) =>
-          isSortable(a) && isSortable(b) ? rule.by(a, b) : 0,
-        );
-      } else {
-        warnings.push(`Rule type "${rule.type}" cannot target the root level`);
-      }
-      continue;
-    }
-
-    switch (rule.type) {
-      case "remove":
-        match.parentItems.splice(match.index, 1);
-        break;
-      case "modify":
-        match.parentItems[match.index] = { ...match.item, ...rule.set };
-        break;
-      case "insert": {
-        const offset = rule.position === "after" ? 1 : 0;
-        match.parentItems.splice(match.index + offset, 0, ...rule.items);
-        break;
-      }
-      case "sort": {
-        const sortableItems =
-          match.item.type === "category" ? match.item.items : undefined;
-
-        if (sortableItems) {
-          sortableItems.sort((a, b) =>
-            isSortable(a) && isSortable(b) ? rule.by(a, b) : 0,
-          );
-        } else {
-          warnings.push(`Sort target "${rule.match}" is not a category`);
-        }
-        break;
-      }
-      case "move": {
-        const toPath = normalizeRulePath(rule.to, topNavLabel);
-        if (toPath === undefined) break;
-
-        const [item] = match.parentItems.splice(match.index, 1);
-        if (!item) break;
-
-        const target = findByPath(result, toPath);
-        if (!target || target.isRoot) {
-          warnings.push(`Move target "${rule.to}" not found`);
-          match.parentItems.splice(match.index, 0, item);
-          break;
-        }
-
-        const offset = rule.position === "after" ? 1 : 0;
-        target.parentItems.splice(target.index + offset, 0, item);
-        break;
-      }
-    }
-  }
-
-  return { result, warnings };
-};
+import type {
+  NavigationItem,
+  ResolvedNavigationRule,
+  SortableNavigationItem,
+} from "../../config/validators/NavigationSchema.js";
+import { findByPath } from "./pathMatcher.js";
+
+export const SORTABLE_TYPES = ["doc", "link", "category", "section"] as const;
+export type SortableType = (typeof SORTABLE_TYPES)[number];
+
+const isSortable = (item: NavigationItem): item is SortableNavigationItem =>
+  SORTABLE_TYPES.some((t) => t === item.type);
+
+export type ApplyRulesResult = {
+  result: NavigationItem[];
+  warnings: string[];
+};
+
+const cloneNavigation = (items: NavigationItem[]): NavigationItem[] =>
+  items.map((item) =>
+    item.type === "category"
+      ? { ...item, items: cloneNavigation(item.items) }
+      : { ...item },
+  );
+
+// Strips the top-nav prefix from a rule path if it matches the current label.
+const normalizeRulePath = (rulePath: string, topNavLabel?: string) => {
+  if (!topNavLabel) return rulePath;
+
+  const segments = rulePath.split("/").filter(Boolean);
+  const first = segments[0];
+  if (!first) return rulePath;
+
+  // Number segments can't match a top-nav label
+  if (!Number.isNaN(Number(first))) {
+    return segments.length > 1 ? undefined : rulePath;
+  }
+
+  if (first.toLowerCase() === topNavLabel.toLowerCase()) {
+    const rest = segments.slice(1).join("/");
+    return rest || "/";
+  }
+
+  // Multi-segment path where first segment doesn't match → different context
+  if (segments.length > 1) return undefined;
+
+  // Single segment: apply to sidebar as-is
+  return rulePath;
+};
+
+export const applyRules = (
+  navigation: NavigationItem[],
+  rules: ResolvedNavigationRule[],
+  topNavLabel?: string,
+): ApplyRulesResult => {
+  const result = cloneNavigation(navigation);
+  const warnings: string[] = [];
+
+  for (const rule of rules) {
+    const normalizedPath = normalizeRulePath(rule.match, topNavLabel);
+    if (normalizedPath === undefined) continue;
+
+    const match = findByPath(result, normalizedPath);
+    if (!match) {
+      warnings.push(`Rule target "${rule.match}" not found`);
+      continue;
+    }
+
+    if (match.isRoot) {
+      if (rule.type === "sort") {
+        result.sort((a, b) =>
+          isSortable(a) && isSortable(b) ? rule.by(a, b) : 0,
+        );
+      } else {
+        warnings.push(`Rule type "${rule.type}" cannot target the root level`);
+      }
+      continue;
+    }
+
+    switch (rule.type) {
+      case "remove":
+        match.parentItems.splice(match.index, 1);
+        break;
+      case "modify":
+        match.parentItems[match.index] = { ...match.item, ...rule.set };
+        break;
+      case "insert": {
+        const offset = rule.position === "after" ? 1 : 0;
+        match.parentItems.splice(match.index + offset, 0, ...rule.items);
+        break;
+      }
+      case "sort": {
+        const sortableItems =
+          match.item.type === "category" ? match.item.items : undefined;
+
+        if (sortableItems) {
+          sortableItems.sort((a, b) =>
+            isSortable(a) && isSortable(b) ? rule.by(a, b) : 0,
+          );
+        } else {
+          warnings.push(`Sort target "${rule.match}" is not a category`);
+        }
+        break;
+      }
+      case "move": {
+        const toPath = normalizeRulePath(rule.to, topNavLabel);
+        if (toPath === undefined) break;
+
+        const [item] = match.parentItems.splice(match.index, 1);
+        if (!item) break;
+
+        const target = findByPath(result, toPath);
+        if (!target || target.isRoot) {
+          warnings.push(`Move target "${rule.to}" not found`);
+          match.parentItems.splice(match.index, 0, item);
+          break;
+        }
+
+        const offset = rule.position === "after" ? 1 : 0;
+        target.parentItems.splice(target.index + offset, 0, item);
+        break;
+      }
+    }
+  }
+
+  return { result, warnings };
+};