@forwardimpact/pathway 0.22.0 → 0.23.1

package/src/lib/router-core.js

@@ -1,161 +1,7 @@
 /**
  * Core Router Factory
  *
- * Pure factory function for hash-based routing with no dependencies.
+ * Re-exports from @forwardimpact/libui/router-core.
  */
 
-import { withErrorBoundary } from "./error-boundary.js";
-
-/**
- * @typedef {Object} Route
- * @property {string} pattern - Route pattern with :params
- * @property {RegExp} regex - Compiled pattern
- * @property {string[]} paramNames - Extracted param names
- * @property {Function} handler - Route handler
- */
-
-/**
- * @typedef {Object} RouteMatch
- * @property {Function} handler - Matched handler
- * @property {Object} params - Extracted parameters
- */
-
-/**
- * @typedef {Object} Router
- * @property {(pattern: string, handler: Function) => void} on - Register route
- * @property {(path: string) => void} navigate - Navigate to path
- * @property {() => string} currentPath - Get current hash path
- * @property {() => void} handleRoute - Process current route
- * @property {() => void} start - Begin listening for hash changes
- * @property {() => void} stop - Stop listening for hash changes
- * @property {() => string[]} patterns - Get registered patterns
- */
-
-/**
- * Parse route pattern into regex and param names
- * @param {string} pattern
- * @returns {{ regex: RegExp, paramNames: string[] }}
- */
-function parsePattern(pattern) {
-  const paramNames = [];
-  const regexStr = pattern
-    .replace(/:([^/]+)/g, (_, name) => {
-      paramNames.push(name);
-      return "([^/]+)";
-    })
-    .replace(/\//g, "\\/");
-  return {
-    regex: new RegExp(`^${regexStr}$`),
-    paramNames,
-  };
-}
-
-/**
- * Create a router instance
- * @param {{ onNotFound?: (path: string) => void, onError?: (error: Error) => void, renderError?: (title: string, message: string) => void }} options
- * @returns {Router}
- */
-export function createRouter(options = {}) {
-  const { onNotFound = () => {}, onError, renderError } = options;
-  /** @type {Route[]} */
-  const routes = [];
-  let hashChangeHandler = null;
-
-  /**
-   * Match a path to a route
-   * @param {string} path
-   * @returns {RouteMatch|null}
-   */
-  function matchRoute(path) {
-    for (const route of routes) {
-      const match = path.match(route.regex);
-      if (match) {
-        const params = {};
-        route.paramNames.forEach((name, i) => {
-          params[name] = decodeURIComponent(match[i + 1]);
-        });
-        return { handler: route.handler, params };
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Get current path from hash (including query string)
-   * @returns {string}
-   */
-  function currentPath() {
-    return window.location.hash.slice(1) || "/";
-  }
-
-  /**
-   * Handle the current route
-   */
-  function handleRoute() {
-    const fullPath = currentPath();
-    const path = fullPath.split("?")[0];
-    const matched = matchRoute(path);
-    if (matched) {
-      window.scrollTo(0, 0);
-      matched.handler(matched.params);
-    } else {
-      onNotFound(path);
-    }
-  }
-
-  return {
-    /**
-     * Register a route
-     * @param {string} pattern - Route pattern (e.g., '/skills/:id')
-     * @param {Function} handler - Handler function
-     */
-    on(pattern, handler) {
-      const { regex, paramNames } = parsePattern(pattern);
-      const wrappedHandler = withErrorBoundary(handler, {
-        onError,
-        backPath: "/",
-        backText: "← Back to Home",
-        renderErrorFn: renderError,
-      });
-      routes.push({ pattern, regex, paramNames, handler: wrappedHandler });
-    },
-
-    /**
-     * Navigate to a path
-     * @param {string} path
-     */
-    navigate(path) {
-      window.location.hash = path;
-    },
-
-    currentPath,
-    handleRoute,
-
-    /**
-     * Start listening for hash changes
-     */
-    start() {
-      hashChangeHandler = () => handleRoute();
-      window.addEventListener("hashchange", hashChangeHandler);
-      handleRoute();
-    },
-
-    /**
-     * Stop listening for hash changes
-     */
-    stop() {
-      if (hashChangeHandler) {
-        window.removeEventListener("hashchange", hashChangeHandler);
-        hashChangeHandler = null;
-      }
-    },
-
-    /**
-     * Get all registered route patterns
-     * @returns {string[]}
-     */
-    patterns() {
-      return routes.map((r) => r.pattern);
-    },
-  };
-}
+export { createRouter } from "@forwardimpact/libui/router-core";

package/src/lib/router-pages.js

@@ -1,16 +1,7 @@
 /**
  * Pages Router
  *
- * Router instance for the main app pages.
+ * Re-exports from @forwardimpact/libui/router-pages.
  */
 
-import { createRouter } from "./router-core.js";
-
-/**
- * Create the pages router for the main app
- * @param {{ onNotFound?: (path: string) => void }} options
- * @returns {import('./router-core.js').Router}
- */
-export function createPagesRouter(options = {}) {
-  return createRouter(options);
-}
+export { createPagesRouter } from "@forwardimpact/libui/router-pages";

package/src/lib/router-slides.js

@@ -1,202 +1,7 @@
 /**
  * Slide Router
  *
- * Extended router with navigation state and keyboard controls for slides.
+ * Re-exports from @forwardimpact/libui/router-slides.
  */
 
-import { createRouter } from "./router-core.js";
-
-/**
- * @typedef {Object} SlideRouter
- * @property {(pattern: string, handler: Function) => void} on - Register route
- * @property {(path: string) => void} navigate - Navigate to path
- * @property {() => string} currentPath - Get current hash path
- * @property {() => void} handleRoute - Process current route
- * @property {() => void} start - Begin listening for hash changes
- * @property {() => void} stop - Stop listening for hash changes
- * @property {() => string[]} patterns - Get registered patterns
- * @property {(paths: string[]) => void} setSlideOrder - Define navigation order
- * @property {() => void} next - Navigate to next slide
- * @property {() => void} prev - Navigate to previous slide
- * @property {() => void} home - Navigate to index
- * @property {() => number} currentIndex - Current position in order
- * @property {() => number} totalSlides - Total slide count
- * @property {() => void} startKeyboardNav - Enable keyboard shortcuts
- * @property {() => void} stopKeyboardNav - Disable keyboard shortcuts
- */
-
-/**
- * Create a slide router with navigation capabilities
- * @param {{ onNotFound?: (path: string) => void, renderError?: (title: string, message: string) => void }} options
- * @returns {SlideRouter}
- */
-export function createSlideRouter(options = {}) {
-  const router = createRouter(options);
-  let slideOrder = [];
-  let chapterBoundaries = [];
-  let keyHandler = null;
-
-  /**
-   * Find current position in slide order
-   * @returns {number}
-   */
-  function findCurrentIndex() {
-    const path = router.currentPath();
-    return slideOrder.indexOf(path);
-  }
-
-  /**
-   * Navigate to slide at given index
-   * @param {number} index
-   */
-  function navigateToIndex(index) {
-    if (index >= 0 && index < slideOrder.length) {
-      router.navigate(slideOrder[index]);
-    }
-  }
-
-  const slideRouter = {
-    // Expose core router methods
-    on: router.on,
-    navigate: router.navigate,
-    currentPath: router.currentPath,
-    handleRoute: router.handleRoute,
-    start: router.start,
-    stop: router.stop,
-    patterns: router.patterns,
-
-    /**
-     * Define the slide navigation order
-     * @param {string[]} paths
-     * @param {number[]} boundaries - Indices where chapters start
-     */
-    setSlideOrder(paths, boundaries = []) {
-      slideOrder = paths;
-      chapterBoundaries = boundaries;
-    },
-
-    /**
-     * Navigate to next slide
-     */
-    next() {
-      const idx = findCurrentIndex();
-      navigateToIndex(idx + 1);
-    },
-
-    /**
-     * Navigate to previous slide
-     */
-    prev() {
-      const idx = findCurrentIndex();
-      navigateToIndex(idx - 1);
-    },
-
-    /**
-     * Navigate to previous chapter
-     */
-    prevChapter() {
-      const idx = findCurrentIndex();
-      // Find the previous chapter boundary before current position
-      const prevBoundary = chapterBoundaries.filter((b) => b < idx).pop();
-      if (prevBoundary !== undefined) {
-        navigateToIndex(prevBoundary);
-      } else if (idx > 0) {
-        navigateToIndex(0);
-      }
-    },
-
-    /**
-     * Navigate to next chapter
-     */
-    nextChapter() {
-      const idx = findCurrentIndex();
-      // Find the next chapter boundary after current position
-      const nextBoundary = chapterBoundaries.find((b) => b > idx);
-      if (nextBoundary !== undefined) {
-        navigateToIndex(nextBoundary);
-      }
-    },
-
-    /**
-     * Navigate to first slide (index)
-     */
-    home() {
-      navigateToIndex(0);
-    },
-
-    /**
-     * Get current slide index
-     * @returns {number}
-     */
-    currentIndex() {
-      return findCurrentIndex();
-    },
-
-    /**
-     * Get total number of slides
-     * @returns {number}
-     */
-    totalSlides() {
-      return slideOrder.length;
-    },
-
-    /**
-     * Start keyboard navigation
-     */
-    startKeyboardNav() {
-      keyHandler = (e) => {
-        // Ignore if typing in an input
-        if (e.target.tagName === "INPUT" || e.target.tagName === "TEXTAREA") {
-          return;
-        }
-
-        switch (e.key) {
-          case "ArrowRight":
-          case " ":
-          case "PageDown":
-            e.preventDefault();
-            slideRouter.next();
-            break;
-          case "ArrowLeft":
-          case "PageUp":
-            e.preventDefault();
-            slideRouter.prev();
-            break;
-          case "ArrowDown":
-            e.preventDefault();
-            slideRouter.nextChapter();
-            break;
-          case "ArrowUp":
-            e.preventDefault();
-            slideRouter.prevChapter();
-            break;
-          case "Home":
-            e.preventDefault();
-            slideRouter.home();
-            break;
-          case "End":
-            e.preventDefault();
-            navigateToIndex(slideOrder.length - 1);
-            break;
-          case "Escape":
-            e.preventDefault();
-            slideRouter.home();
-            break;
-        }
-      };
-      document.addEventListener("keydown", keyHandler);
-    },
-
-    /**
-     * Stop keyboard navigation
-     */
-    stopKeyboardNav() {
-      if (keyHandler) {
-        document.removeEventListener("keydown", keyHandler);
-        keyHandler = null;
-      }
-    },
-  };
-
-  return slideRouter;
-}
+export { createSlideRouter } from "@forwardimpact/libui/router-slides";

package/src/lib/state.js

@@ -1,15 +1,13 @@
 /**
  * Application state management
+ *
+ * Uses generic store from @forwardimpact/libui/state
+ * with Pathway-specific state shape and accessors.
  */
 
-/**
- * @typedef {Object} AppState
- * @property {Object} data - Loaded data from YAML files
- * @property {Object} ui - UI state
- */
+import { createStore } from "@forwardimpact/libui/state";
 
-/** @type {AppState} */
-const state = {
+const store = createStore({
   data: {
     skills: [],
     behaviours: [],
@@ -35,48 +33,18 @@ const state = {
       drivers: { search: "" },
     },
   },
-};
-
-/** @type {Set<Function>} */
-const listeners = new Set();
-
-/**
- * Get the current state
- * @returns {AppState}
- */
-export function getState() {
-  return state;
-}
-
-/**
- * Get a specific path from state
- * @param {string} path - Dot-notation path (e.g., 'data.skills')
- * @returns {*}
- */
-export function getStatePath(path) {
-  return path.split(".").reduce((obj, key) => obj?.[key], state);
-}
+});
 
-/**
- * Update state at a specific path
- * @param {string} path - Dot-notation path
- * @param {*} value - New value
- */
-export function updateState(path, value) {
-  const keys = path.split(".");
-  const lastKey = keys.pop();
-  const target = keys.reduce((obj, key) => obj[key], state);
-  target[lastKey] = value;
-  notifyListeners();
-}
+export const { getState, getStatePath, updateState, subscribe } = store;
 
 /**
  * Merge data into state
  * @param {Object} data - Data to merge
  */
 export function setData(data) {
+  const state = getState();
   Object.assign(state.data, data, { loaded: true, error: null });
-  notifyListeners();
+  updateState("data", state.data);
 }
 
 /**
@@ -84,25 +52,7 @@ export function setData(data) {
  * @param {Error} error
  */
 export function setError(error) {
-  state.data.error = error.message;
-  notifyListeners();
-}
-
-/**
- * Subscribe to state changes
- * @param {Function} listener
- * @returns {Function} Unsubscribe function
- */
-export function subscribe(listener) {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-
-/**
- * Notify all listeners of state change
- */
-function notifyListeners() {
-  listeners.forEach((listener) => listener(state));
+  updateState("data.error", error.message);
 }
 
 /**
@@ -112,9 +62,10 @@ function notifyListeners() {
  * @param {*} value - Filter value
  */
 export function setFilter(entity, filterKey, value) {
+  const state = getState();
   if (state.ui.filters[entity]) {
     state.ui.filters[entity][filterKey] = value;
-    notifyListeners();
+    updateState("ui.filters", state.ui.filters);
   }
 }
 
@@ -124,7 +75,7 @@ export function setFilter(entity, filterKey, value) {
  * @returns {Object}
  */
 export function getFilters(entity) {
-  return state.ui.filters[entity] || {};
+  return getState().ui.filters[entity] || {};
 }
 
 /**
@@ -140,7 +91,7 @@ export function getFilters(entity) {
  * @returns {Branding}
  */
 export function getBranding() {
-  const { framework } = state.data;
+  const { framework } = getState().data;
   return {
     title: framework.title || "Engineering Pathway",
     tag: framework.tag || "#BenchTools",

package/src/lib/utils.js

@@ -1,14 +1,7 @@
 /**
  * General utility functions
+ *
+ * Re-exports from @forwardimpact/libui/utils.
  */
 
-/**
- * Get an array of items by their IDs
- * @param {Array} items - Array of items with id property
- * @param {string[]} ids - Array of IDs to find
- * @returns {Array} - Found items, filtered to remove nulls
- */
-export function getItemsByIds(items, ids) {
-  if (!ids) return [];
-  return ids.map((id) => items.find((item) => item.id === id)).filter(Boolean);
-}
+export { getItemsByIds } from "@forwardimpact/libui/utils";