giggles 0.1.1 → 0.2.0

package/README.md

@@ -1 +1,6 @@
+[![CI](https://github.com/zion-off/giggles/actions/workflows/giggles-lint.yml/badge.svg)](https://github.com/zion-off/giggles/actions/workflows/giggles-lint.yml)
+[![CD](https://github.com/zion-off/giggles/actions/workflows/giggles-cd.yml/badge.svg)](https://github.com/zion-off/giggles/actions/workflows/giggles-cd.yml)
+[![npm version](https://img.shields.io/npm/v/giggles)](https://www.npmjs.com/package/giggles)
+[![npm downloads](https://img.shields.io/npm/dm/giggles)](https://www.npmjs.com/package/giggles)
+
 wip -- see [giggles.zzzzion.com](https://giggles.zzzzion.com)!

package/dist/index.d.ts

@@ -4,6 +4,10 @@ import React__default from 'react';
 import { Key } from 'ink';
 export { Key } from 'ink';
 
+declare class GigglesError extends Error {
+    constructor(message: string);
+}
+
 type GigglesProviderProps = {
     children: React__default.ReactNode;
 };
@@ -23,6 +27,7 @@ type FocusHandle = {
     focused: boolean;
     focus: () => void;
 };
+
 declare const useFocus: (id?: string) => FocusHandle;
 
 declare function useFocusState<T extends string>(initial: T): readonly [T, React$1.Dispatch<React$1.SetStateAction<T>>];
@@ -44,4 +49,34 @@ type FocusTrapProps = {
 };
 declare function FocusTrap({ children }: FocusTrapProps): react_jsx_runtime.JSX.Element;
 
-export { FocusGroup, type FocusHandle, FocusTrap, GigglesProvider, type KeyHandler, type KeybindingOptions, type Keybindings, useFocus, useFocusState, useKeybindings };
+type RouterProps = {
+    children: React__default.ReactNode;
+    initialScreen: string;
+    initialParams?: Record<string, unknown>;
+};
+declare function Router({ children, initialScreen, initialParams }: RouterProps): react_jsx_runtime.JSX.Element;
+
+type ScreenProps = {
+    name: string;
+    component: React__default.ComponentType<Record<string, unknown>>;
+};
+declare function Screen(_props: ScreenProps): null;
+
+type ScreenRoute = {
+    id: number;
+    name: string;
+    params?: Record<string, unknown>;
+};
+type NavigationContextValue = {
+    currentRoute: ScreenRoute;
+    canGoBack: boolean;
+    active: boolean;
+    push(name: string, params?: Record<string, unknown>): void;
+    pop(): void;
+    replace(name: string, params?: Record<string, unknown>): void;
+    reset(name: string, params?: Record<string, unknown>): void;
+};
+
+declare const useNavigation: () => NavigationContextValue;
+
+export { FocusGroup, type FocusHandle, FocusTrap, GigglesError, GigglesProvider, type KeyHandler, type KeybindingOptions, type Keybindings, type NavigationContextValue, Router, Screen, type ScreenRoute, useFocus, useFocusState, useKeybindings, useNavigation };

package/dist/index.js

@@ -1,3 +1,11 @@
+// src/core/GigglesError.ts
+var GigglesError = class extends Error {
+  constructor(message) {
+    super(`[giggles] ${message}`);
+    this.name = "GigglesError";
+  }
+};
+
 // src/core/focus/FocusContext.tsx
 import { createContext, useCallback, useContext, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
@@ -145,7 +153,7 @@ var FocusNodeContext = createContext(null);
 var useFocusContext = () => {
   const context = useContext(FocusContext);
   if (!context) {
-    throw new Error("useFocusContext must be used within a FocusProvider");
+    throw new GigglesError("useFocusContext must be used within a FocusProvider");
   }
   return context;
 };
@@ -219,7 +227,7 @@ var InputProvider = ({ children }) => {
 function useInputContext() {
   const context = useContext2(InputContext);
   if (!context) {
-    throw new Error("useInputContext must be used within an InputProvider");
+    throw new GigglesError("useInputContext must be used within an InputProvider");
   }
   return context;
 }
@@ -300,15 +308,15 @@ function FocusTrap({ children }) {
 }
 
 // src/core/focus/FocusBindContext.tsx
-import { createContext as createContext3, useContext as useContext3 } from "react";
+import { createContext as createContext3 } from "react";
 var FocusBindContext = createContext3(null);
 
 // src/core/focus/useFocus.ts
-import { useContext as useContext4, useEffect as useEffect3, useId } from "react";
+import { useContext as useContext3, useEffect as useEffect3, useId } from "react";
 var useFocus = (id) => {
   const nodeId = useId();
-  const parentId = useContext4(FocusNodeContext);
-  const bindContext = useContext4(FocusBindContext);
+  const parentId = useContext3(FocusNodeContext);
+  const bindContext = useContext3(FocusBindContext);
   const { focusNode, registerNode, unregisterNode, isFocused } = useFocusContext();
   useEffect3(() => {
     registerNode(nodeId, parentId);
@@ -343,7 +351,7 @@ function FocusGroup({
   const bindMapRef = useRef3(/* @__PURE__ */ new Map());
   const register = useCallback3((logicalId, nodeId) => {
     if (bindMapRef.current.has(logicalId)) {
-      throw new Error(`FocusGroup: Duplicate id "${logicalId}". Each child must have a unique id.`);
+      throw new GigglesError(`FocusGroup: Duplicate id "${logicalId}". Each child must have a unique id.`);
     }
     bindMapRef.current.set(logicalId, nodeId);
   }, []);
@@ -391,11 +399,140 @@ import { jsx as jsx6 } from "react/jsx-runtime";
 function GigglesProvider({ children }) {
   return /* @__PURE__ */ jsx6(FocusProvider, { children: /* @__PURE__ */ jsx6(InputProvider, { children: /* @__PURE__ */ jsx6(InputRouter, { children }) }) });
 }
+
+// src/core/router/Router.tsx
+import React4, { useCallback as useCallback4, useReducer, useRef as useRef4 } from "react";
+
+// src/core/router/Screen.tsx
+function Screen(_props) {
+  return null;
+}
+
+// src/core/router/ScreenEntry.tsx
+import { useMemo as useMemo2 } from "react";
+import { Box } from "ink";
+
+// src/core/router/NavigationContext.tsx
+import { createContext as createContext4, useContext as useContext4 } from "react";
+var NavigationContext = createContext4(null);
+var useNavigation = () => {
+  const context = useContext4(NavigationContext);
+  if (!context) {
+    throw new GigglesError("useNavigation must be used within a Router");
+  }
+  return context;
+};
+
+// src/core/router/ScreenEntry.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function ScreenEntry({
+  entry,
+  isTop,
+  canGoBack,
+  component: Component,
+  push,
+  pop,
+  replace,
+  reset
+}) {
+  const value = useMemo2(
+    () => ({ currentRoute: entry, active: isTop, canGoBack, push, pop, replace, reset }),
+    [entry, isTop, canGoBack, push, pop, replace, reset]
+  );
+  return /* @__PURE__ */ jsx7(NavigationContext.Provider, { value, children: /* @__PURE__ */ jsx7(Box, { display: isTop ? "flex" : "none", children: /* @__PURE__ */ jsx7(Component, { ...entry.params }) }) });
+}
+
+// src/core/router/Router.tsx
+import { Fragment as Fragment3, jsx as jsx8 } from "react/jsx-runtime";
+function routerReducer(stack, action) {
+  switch (action.type) {
+    case "push":
+      return [...stack, action.route];
+    case "pop":
+      return stack.length > 1 ? stack.slice(0, -1) : stack;
+    case "replace":
+      return [...stack.slice(0, -1), action.route];
+    case "reset":
+      return [action.route];
+  }
+}
+function Router({ children, initialScreen, initialParams }) {
+  const screenId = useRef4(0);
+  const routes = React4.Children.toArray(children).filter((child) => React4.isValidElement(child) && child.type === Screen).map((child) => child.props);
+  const screenNamesRef = useRef4(/* @__PURE__ */ new Set());
+  screenNamesRef.current = new Set(routes.map((r) => r.name));
+  const assertScreen = useCallback4((name) => {
+    if (!screenNamesRef.current.has(name)) {
+      throw new GigglesError(
+        `Screen "${name}" is not registered. Available screens: ${[...screenNamesRef.current].join(", ")}`
+      );
+    }
+  }, []);
+  const [stack, dispatch] = useReducer(routerReducer, initialScreen, (name) => {
+    if (!screenNamesRef.current.has(name)) {
+      throw new GigglesError(
+        `Initial screen "${name}" is not registered. Available screens: ${[...screenNamesRef.current].join(", ")}`
+      );
+    }
+    return [{ id: screenId.current++, name, params: initialParams }];
+  });
+  const push = useCallback4(
+    (name, params) => {
+      assertScreen(name);
+      dispatch({ type: "push", route: { id: screenId.current++, name, params } });
+    },
+    [assertScreen]
+  );
+  const pop = useCallback4(() => {
+    dispatch({ type: "pop" });
+  }, []);
+  const replace = useCallback4(
+    (name, params) => {
+      assertScreen(name);
+      dispatch({ type: "replace", route: { id: screenId.current++, name, params } });
+    },
+    [assertScreen]
+  );
+  const reset = useCallback4(
+    (name, params) => {
+      assertScreen(name);
+      dispatch({ type: "reset", route: { id: screenId.current++, name, params } });
+    },
+    [assertScreen]
+  );
+  const components = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    components.set(route.name, route.component);
+  }
+  const canGoBack = stack.length > 1;
+  return /* @__PURE__ */ jsx8(Fragment3, { children: stack.map((entry, i) => {
+    const Component = components.get(entry.name);
+    if (!Component) return null;
+    return /* @__PURE__ */ jsx8(
+      ScreenEntry,
+      {
+        entry,
+        isTop: i === stack.length - 1,
+        canGoBack,
+        component: Component,
+        push,
+        pop,
+        replace,
+        reset
+      },
+      entry.id
+    );
+  }) });
+}
 export {
   FocusGroup,
   FocusTrap,
+  GigglesError,
   GigglesProvider,
+  Router,
+  Screen,
   useFocus,
   useFocusState,
-  useKeybindings
+  useKeybindings,
+  useNavigation
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "giggles",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",