@seed-design/stackflow 0.0.1-rc.1 → 0.0.1-rc.3

package/lib/primitive/AppScreen/useAppScreen.js

@@ -0,0 +1,60 @@
+import { dataAttr, elementProps } from '@seed-design/dom-utils';
+import { useNullableActivity, useZIndexBase } from '@stackflow/react-ui-core';
+import { useMemo } from 'react';
+import { useSwipeBack } from '../GlobalInteraction/useSwipeBack.js';
+
+function useAppScreen(props) {
+  const activity = useNullableActivity();
+  const transitionState = activity?.transitionState ?? "enter-done";
+  const { activityProps, layerProps, edgeProps } = useSwipeBack(props);
+  const zIndexBase = useZIndexBase();
+  const zIndexStyle = useMemo(
+    () => ({
+      "--z-index-base": zIndexBase.toString()
+    }),
+    [zIndexBase]
+  );
+  const stateProps = useMemo(
+    () => ({
+      "data-activity-is-top": dataAttr(activity?.isTop),
+      "data-activity-is-active": dataAttr(activity?.isActive),
+      "data-transition-state": transitionState
+    }),
+    [transitionState, activity?.isActive, activity?.isTop]
+  );
+  return useMemo(
+    () => ({
+      activity,
+      stateProps,
+      activityProps: elementProps({
+        "data-part": "activity",
+        "data-activity-type": "full-screen",
+        ...activityProps,
+        ...stateProps,
+        "data-activity-id": activity?.id,
+        style: zIndexStyle,
+        // FIXME: @stackflow/react should prevent activity.id hydration mismatch; this is temporal fix.
+        suppressHydrationWarning: true
+      }),
+      dimProps: elementProps({
+        "data-part": "dim",
+        ...stateProps
+      }),
+      layerProps: elementProps({
+        "data-part": "layer",
+        ...stateProps,
+        ...layerProps
+      }),
+      edgeProps: elementProps({
+        "data-part": "edge",
+        "aria-hidden": true,
+        tabIndex: -1,
+        ...edgeProps,
+        ...stateProps
+      })
+    }),
+    [activity, zIndexStyle, stateProps, activityProps, edgeProps, layerProps]
+  );
+}
+
+export { useAppScreen };

package/lib/primitive/AppScreen/useAppScreenContext.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const React = require('react');
+
+const AppScreenContext = React.createContext(null);
+const AppScreenProvider = AppScreenContext.Provider;
+function useAppScreenContext({
+  strict = true
+} = {}) {
+  const context = React.useContext(AppScreenContext);
+  if (!context && strict) {
+    throw new Error("useAppScreenContext must be used within a AppScreen");
+  }
+  return context;
+}
+
+exports.AppScreenProvider = AppScreenProvider;
+exports.useAppScreenContext = useAppScreenContext;

package/lib/primitive/AppScreen/useAppScreenContext.d.ts

@@ -1,7 +1,8 @@
-import type { UseAppScreenReturn } from "./useAppScreen";
+import { UseAppScreenReturn } from './useAppScreen';
+import { Provider } from 'react';
 export interface UseAppScreenContext extends UseAppScreenReturn {
 }
-export declare const AppScreenProvider: import("react").Provider<UseAppScreenContext | null>;
+export declare const AppScreenProvider: Provider<UseAppScreenContext | null>;
 export declare function useAppScreenContext<T extends boolean | undefined = true>({ strict, }?: {
     strict?: T;
 }): T extends false ? UseAppScreenContext | null : UseAppScreenContext;

package/lib/primitive/AppScreen/useAppScreenContext.js

@@ -0,0 +1,15 @@
+import { createContext, useContext } from 'react';
+
+const AppScreenContext = createContext(null);
+const AppScreenProvider = AppScreenContext.Provider;
+function useAppScreenContext({
+  strict = true
+} = {}) {
+  const context = useContext(AppScreenContext);
+  if (!context && strict) {
+    throw new Error("useAppScreenContext must be used within a AppScreen");
+  }
+  return context;
+}
+
+export { AppScreenProvider, useAppScreenContext };

package/lib/primitive/GlobalInteraction/GlobalInteraction.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const jsxRuntime = require('react/jsx-runtime');
+const reactComposeRefs = require('@radix-ui/react-compose-refs');
+const domUtils = require('@seed-design/dom-utils');
+const reactPrimitive = require('@seed-design/react-primitive');
+const React = require('react');
+const useGlobalInteraction = require('./useGlobalInteraction.cjs');
+const useGlobalInteractionContext = require('./useGlobalInteractionContext.cjs');
+
+const GlobalInteraction = React.forwardRef(
+  (props, ref) => {
+    const api = useGlobalInteraction.useGlobalInteraction();
+    return /* @__PURE__ */ jsxRuntime.jsx(useGlobalInteractionContext.GlobalInteractionProvider, { value: api, children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactPrimitive.Primitive.div,
+      {
+        ref: reactComposeRefs.composeRefs(api.stackRef, ref),
+        ...domUtils.mergeProps(api.stackProps, props)
+      }
+    ) });
+  }
+);
+GlobalInteraction.displayName = "GlobalInteraction";
+
+exports.GlobalInteraction = GlobalInteraction;

package/lib/primitive/GlobalInteraction/GlobalInteraction.d.ts

@@ -1,4 +1,5 @@
-import { type PrimitiveProps } from "@seed-design/react-primitive";
+import { PrimitiveProps } from '@seed-design/react-primitive';
+import { ForwardRefExoticComponent, RefAttributes } from 'react';
 export interface GlobalInteractionProps extends PrimitiveProps, React.HTMLAttributes<HTMLDivElement> {
 }
-export declare const GlobalInteraction: import("react").ForwardRefExoticComponent<GlobalInteractionProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const GlobalInteraction: ForwardRefExoticComponent<GlobalInteractionProps & RefAttributes<HTMLDivElement>>;

package/lib/primitive/GlobalInteraction/GlobalInteraction.js

@@ -0,0 +1,23 @@
+import { jsx } from 'react/jsx-runtime';
+import { composeRefs } from '@radix-ui/react-compose-refs';
+import { mergeProps } from '@seed-design/dom-utils';
+import { Primitive } from '@seed-design/react-primitive';
+import { forwardRef } from 'react';
+import { useGlobalInteraction } from './useGlobalInteraction.js';
+import { GlobalInteractionProvider } from './useGlobalInteractionContext.js';
+
+const GlobalInteraction = forwardRef(
+  (props, ref) => {
+    const api = useGlobalInteraction();
+    return /* @__PURE__ */ jsx(GlobalInteractionProvider, { value: api, children: /* @__PURE__ */ jsx(
+      Primitive.div,
+      {
+        ref: composeRefs(api.stackRef, ref),
+        ...mergeProps(api.stackProps, props)
+      }
+    ) });
+  }
+);
+GlobalInteraction.displayName = "GlobalInteraction";
+
+export { GlobalInteraction };

package/lib/primitive/GlobalInteraction/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const GlobalInteraction = require('./GlobalInteraction.cjs');
+const useGlobalInteractionContext = require('./useGlobalInteractionContext.cjs');
+
+
+
+exports.GlobalInteraction = GlobalInteraction.GlobalInteraction;
+exports.useGlobalInteractionContext = useGlobalInteractionContext.useGlobalInteractionContext;

package/lib/primitive/GlobalInteraction/index.d.ts

@@ -1,2 +1,2 @@
-export { GlobalInteraction, type GlobalInteractionProps } from "./GlobalInteraction";
-export { useGlobalInteractionContext, type UseGlobalInteractionContext, } from "./useGlobalInteractionContext";
+export { GlobalInteraction, type GlobalInteractionProps } from './GlobalInteraction';
+export { useGlobalInteractionContext, type UseGlobalInteractionContext, } from './useGlobalInteractionContext';

package/lib/primitive/GlobalInteraction/index.js

@@ -0,0 +1,2 @@
+export { GlobalInteraction } from './GlobalInteraction.js';
+export { useGlobalInteractionContext } from './useGlobalInteractionContext.js';

package/lib/primitive/GlobalInteraction/useGlobalInteraction.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const reactUseCallbackRef = require('@radix-ui/react-use-callback-ref');
+const React = require('react');
+const useTopActivity = require('../private/useTopActivity.cjs');
+
+function useGlobalInteraction() {
+  const [swipeBackState, setSwipeBackState] = React.useState("idle");
+  const swipeBackContextRef = React.useRef({
+    x0: 0,
+    t0: 0,
+    displacement: 0,
+    displacementRatio: 0,
+    velocity: 0
+  });
+  const stackRef = React.useRef(null);
+  const setSwipeBackContext = React.useCallback((ctx) => {
+    swipeBackContextRef.current = ctx;
+    stackRef.current?.style.setProperty(
+      "--swipe-back-displacement",
+      `${ctx.displacement.toString()}px`
+    );
+    stackRef.current?.style.setProperty(
+      "--swipe-back-displacement-ratio",
+      ctx.displacementRatio.toString()
+    );
+  }, []);
+  const getSwipeBackEvents = React.useCallback(
+    (props) => {
+      const {
+        swipeBackDisplacementRatioThreshold: displacementRatioThreshold = 0.4,
+        swipeBackVelocityThreshold: velocityThreshold = 1
+      } = props;
+      const onSwipeStart = reactUseCallbackRef.useCallbackRef(props.onSwipeBackStart);
+      const onSwipeMove = reactUseCallbackRef.useCallbackRef(props.onSwipeBackMove);
+      const onSwipeEnd = reactUseCallbackRef.useCallbackRef(props.onSwipeBackEnd);
+      const startSwipeBack = React.useCallback(
+        ({ x0, t0 }) => {
+          setSwipeBackContext({
+            x0,
+            t0,
+            displacement: 0,
+            displacementRatio: 0,
+            velocity: 0
+          });
+          setSwipeBackState("swiping");
+          onSwipeStart?.();
+        },
+        [onSwipeStart]
+      );
+      const moveSwipeBack = React.useCallback(
+        ({ x, t }) => {
+          const displacement = x - swipeBackContextRef.current.x0;
+          const displacementRatio = displacement / window.innerWidth;
+          const velocity = displacement / (t - swipeBackContextRef.current.t0);
+          setSwipeBackContext({
+            ...swipeBackContextRef.current,
+            displacement,
+            displacementRatio,
+            velocity
+          });
+          setSwipeBackState("swiping");
+          onSwipeMove?.({ displacement, displacementRatio });
+        },
+        [onSwipeMove]
+      );
+      const endSwipeBack = React.useCallback(
+        (_) => {
+          const swiped = swipeBackContextRef.current.displacementRatio > displacementRatioThreshold || swipeBackContextRef.current.velocity > velocityThreshold;
+          setSwipeBackState("transitioning");
+          onSwipeEnd?.({ swiped });
+        },
+        [onSwipeEnd, displacementRatioThreshold, velocityThreshold]
+      );
+      const reset = React.useCallback(() => {
+        setSwipeBackContext({
+          x0: 0,
+          t0: 0,
+          displacement: 0,
+          displacementRatio: 0,
+          velocity: 0
+        });
+        setSwipeBackState("idle");
+      }, []);
+      return React.useMemo(
+        () => ({
+          startSwipeBack,
+          moveSwipeBack,
+          endSwipeBack,
+          reset
+        }),
+        [startSwipeBack, moveSwipeBack, endSwipeBack, reset]
+      );
+    },
+    [setSwipeBackContext]
+  );
+  const topActivity = useTopActivity.useTopActivity();
+  const stackProps = React.useMemo(
+    () => ({
+      "data-swipe-back-state": swipeBackState,
+      "data-global-transition-state": topActivity.transitionState,
+      "data-top-activity-type": topActivity.activityType
+    }),
+    [swipeBackState, topActivity.transitionState, topActivity.activityType]
+  );
+  return React.useMemo(
+    () => ({
+      stackRef,
+      swipeBackContextRef,
+      swipeBackState,
+      setSwipeBackState,
+      setSwipeBackContext,
+      getSwipeBackEvents,
+      stackProps
+    }),
+    [swipeBackState, setSwipeBackContext, getSwipeBackEvents, stackProps]
+  );
+}
+
+exports.useGlobalInteraction = useGlobalInteraction;

package/lib/primitive/GlobalInteraction/useGlobalInteraction.d.ts

@@ -1,3 +1,4 @@
+import { RefObject, MutableRefObject, Dispatch, SetStateAction, HTMLAttributes } from 'react';
 export type SwipeBackState = "idle" | "swiping" | "transitioning";
 export type UseGlobalInteractionReturn = ReturnType<typeof useGlobalInteraction>;
 export interface SwipeBackContext {
@@ -38,10 +39,10 @@ export interface MoveSwipeBackProps {
 export interface EndSwipeBackProps {
 }
 export declare function useGlobalInteraction(): {
-    stackRef: import("react").RefObject<HTMLDivElement>;
-    swipeBackContextRef: import("react").MutableRefObject<SwipeBackContext>;
+    stackRef: RefObject<HTMLDivElement>;
+    swipeBackContextRef: MutableRefObject<SwipeBackContext>;
     swipeBackState: SwipeBackState;
-    setSwipeBackState: import("react").Dispatch<import("react").SetStateAction<SwipeBackState>>;
+    setSwipeBackState: Dispatch<SetStateAction<SwipeBackState>>;
     setSwipeBackContext: (ctx: SwipeBackContext) => void;
     getSwipeBackEvents: (props: SwipeBackProps) => {
         startSwipeBack: ({ x0, t0 }: StartSwipeBackProps) => void;
@@ -49,5 +50,5 @@ export declare function useGlobalInteraction(): {
         endSwipeBack: (_: EndSwipeBackProps) => void;
         reset: () => void;
     };
-    stackProps: import("react").HTMLAttributes<HTMLElement>;
+    stackProps: HTMLAttributes<HTMLElement>;
 };

package/lib/primitive/GlobalInteraction/useGlobalInteraction.js

@@ -0,0 +1,118 @@
+import { useCallbackRef } from '@radix-ui/react-use-callback-ref';
+import { useState, useRef, useCallback, useMemo } from 'react';
+import { useTopActivity } from '../private/useTopActivity.js';
+
+function useGlobalInteraction() {
+  const [swipeBackState, setSwipeBackState] = useState("idle");
+  const swipeBackContextRef = useRef({
+    x0: 0,
+    t0: 0,
+    displacement: 0,
+    displacementRatio: 0,
+    velocity: 0
+  });
+  const stackRef = useRef(null);
+  const setSwipeBackContext = useCallback((ctx) => {
+    swipeBackContextRef.current = ctx;
+    stackRef.current?.style.setProperty(
+      "--swipe-back-displacement",
+      `${ctx.displacement.toString()}px`
+    );
+    stackRef.current?.style.setProperty(
+      "--swipe-back-displacement-ratio",
+      ctx.displacementRatio.toString()
+    );
+  }, []);
+  const getSwipeBackEvents = useCallback(
+    (props) => {
+      const {
+        swipeBackDisplacementRatioThreshold: displacementRatioThreshold = 0.4,
+        swipeBackVelocityThreshold: velocityThreshold = 1
+      } = props;
+      const onSwipeStart = useCallbackRef(props.onSwipeBackStart);
+      const onSwipeMove = useCallbackRef(props.onSwipeBackMove);
+      const onSwipeEnd = useCallbackRef(props.onSwipeBackEnd);
+      const startSwipeBack = useCallback(
+        ({ x0, t0 }) => {
+          setSwipeBackContext({
+            x0,
+            t0,
+            displacement: 0,
+            displacementRatio: 0,
+            velocity: 0
+          });
+          setSwipeBackState("swiping");
+          onSwipeStart?.();
+        },
+        [onSwipeStart]
+      );
+      const moveSwipeBack = useCallback(
+        ({ x, t }) => {
+          const displacement = x - swipeBackContextRef.current.x0;
+          const displacementRatio = displacement / window.innerWidth;
+          const velocity = displacement / (t - swipeBackContextRef.current.t0);
+          setSwipeBackContext({
+            ...swipeBackContextRef.current,
+            displacement,
+            displacementRatio,
+            velocity
+          });
+          setSwipeBackState("swiping");
+          onSwipeMove?.({ displacement, displacementRatio });
+        },
+        [onSwipeMove]
+      );
+      const endSwipeBack = useCallback(
+        (_) => {
+          const swiped = swipeBackContextRef.current.displacementRatio > displacementRatioThreshold || swipeBackContextRef.current.velocity > velocityThreshold;
+          setSwipeBackState("transitioning");
+          onSwipeEnd?.({ swiped });
+        },
+        [onSwipeEnd, displacementRatioThreshold, velocityThreshold]
+      );
+      const reset = useCallback(() => {
+        setSwipeBackContext({
+          x0: 0,
+          t0: 0,
+          displacement: 0,
+          displacementRatio: 0,
+          velocity: 0
+        });
+        setSwipeBackState("idle");
+      }, []);
+      return useMemo(
+        () => ({
+          startSwipeBack,
+          moveSwipeBack,
+          endSwipeBack,
+          reset
+        }),
+        [startSwipeBack, moveSwipeBack, endSwipeBack, reset]
+      );
+    },
+    [setSwipeBackContext]
+  );
+  const topActivity = useTopActivity();
+  const stackProps = useMemo(
+    () => ({
+      "data-swipe-back-state": swipeBackState,
+      "data-global-transition-state": topActivity.transitionState,
+      "data-top-activity-type": topActivity.activityType
+    }),
+    [swipeBackState, topActivity.transitionState, topActivity.activityType]
+  );
+  return useMemo(
+    () => ({
+      stackRef,
+      swipeBackContextRef,
+      swipeBackState,
+      setSwipeBackState,
+      setSwipeBackContext,
+      getSwipeBackEvents,
+      stackProps
+    }),
+    [swipeBackState, setSwipeBackContext, getSwipeBackEvents, stackProps]
+  );
+}
+
+export { useGlobalInteraction };

package/lib/primitive/GlobalInteraction/useGlobalInteractionContext.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const React = require('react');
+
+const GlobalInteractionContext = React.createContext(null);
+const GlobalInteractionProvider = GlobalInteractionContext.Provider;
+function useGlobalInteractionContext({
+  strict = true
+} = {}) {
+  const context = React.useContext(GlobalInteractionContext);
+  if (!context && strict) {
+    throw new Error("useGlobalInteractionContext must be used within a GlobalInteractionProvider");
+  }
+  return context;
+}
+
+exports.GlobalInteractionProvider = GlobalInteractionProvider;
+exports.useGlobalInteractionContext = useGlobalInteractionContext;

package/lib/primitive/GlobalInteraction/useGlobalInteractionContext.d.ts

@@ -1,7 +1,8 @@
-import type { UseGlobalInteractionReturn } from "./useGlobalInteraction";
+import { UseGlobalInteractionReturn } from './useGlobalInteraction';
+import { Provider } from 'react';
 export interface UseGlobalInteractionContext extends UseGlobalInteractionReturn {
 }
-export declare const GlobalInteractionProvider: import("react").Provider<UseGlobalInteractionContext | null>;
+export declare const GlobalInteractionProvider: Provider<UseGlobalInteractionContext | null>;
 export declare function useGlobalInteractionContext<T extends boolean | undefined = true>({ strict, }?: {
     strict?: T;
 }): T extends false ? UseGlobalInteractionContext | null : UseGlobalInteractionContext;

package/lib/primitive/GlobalInteraction/useGlobalInteractionContext.js

@@ -0,0 +1,15 @@
+import { createContext, useContext } from 'react';
+
+const GlobalInteractionContext = createContext(null);
+const GlobalInteractionProvider = GlobalInteractionContext.Provider;
+function useGlobalInteractionContext({
+  strict = true
+} = {}) {
+  const context = useContext(GlobalInteractionContext);
+  if (!context && strict) {
+    throw new Error("useGlobalInteractionContext must be used within a GlobalInteractionProvider");
+  }
+  return context;
+}
+
+export { GlobalInteractionProvider, useGlobalInteractionContext };

package/lib/primitive/GlobalInteraction/useSwipeBack.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const React = require('react');
+const useGlobalInteractionContext = require('./useGlobalInteractionContext.cjs');
+
+function useSwipeBack(props) {
+  const globalInteraction = useGlobalInteractionContext.useGlobalInteractionContext();
+  const events = globalInteraction.getSwipeBackEvents(props);
+  React.useEffect(() => {
+    return () => {
+      events.reset();
+    };
+  }, [events]);
+  return React.useMemo(
+    () => ({
+      activityProps: {
+        "data-swipe-back": ""
+      },
+      layerProps: {
+        onTransitionEnd: (e) => {
+          if (e.target === e.currentTarget) {
+            events.reset();
+          }
+        },
+        onAnimationEnd: (e) => {
+          if (e.target === e.currentTarget) {
+            events.reset();
+          }
+        }
+      },
+      edgeProps: {
+        tabIndex: -1,
+        onTouchStart: (e) => {
+          const x0 = e.touches[0].clientX;
+          const t0 = Date.now();
+          events.startSwipeBack({ x0, t0 });
+        },
+        onTouchMove: (e) => {
+          const x = e.touches[0].clientX;
+          const t = Date.now();
+          events.moveSwipeBack({ x, t });
+        },
+        onTouchEnd: () => {
+          events.endSwipeBack({});
+        },
+        onTouchCancel: () => {
+          events.endSwipeBack({});
+        }
+      }
+    }),
+    [events]
+  );
+}
+
+exports.useSwipeBack = useSwipeBack;

package/lib/primitive/GlobalInteraction/useSwipeBack.d.ts

@@ -1,4 +1,4 @@
-import type { SwipeBackProps } from "./useGlobalInteraction";
+import { SwipeBackProps } from './useGlobalInteraction';
 export interface UseSwipeBackProps extends SwipeBackProps {
 }
 export declare function useSwipeBack(props: UseSwipeBackProps): {

package/lib/primitive/GlobalInteraction/useSwipeBack.js

@@ -0,0 +1,53 @@
+import { useEffect, useMemo } from 'react';
+import { useGlobalInteractionContext } from './useGlobalInteractionContext.js';
+
+function useSwipeBack(props) {
+  const globalInteraction = useGlobalInteractionContext();
+  const events = globalInteraction.getSwipeBackEvents(props);
+  useEffect(() => {
+    return () => {
+      events.reset();
+    };
+  }, [events]);
+  return useMemo(
+    () => ({
+      activityProps: {
+        "data-swipe-back": ""
+      },
+      layerProps: {
+        onTransitionEnd: (e) => {
+          if (e.target === e.currentTarget) {
+            events.reset();
+          }
+        },
+        onAnimationEnd: (e) => {
+          if (e.target === e.currentTarget) {
+            events.reset();
+          }
+        }
+      },
+      edgeProps: {
+        tabIndex: -1,
+        onTouchStart: (e) => {
+          const x0 = e.touches[0].clientX;
+          const t0 = Date.now();
+          events.startSwipeBack({ x0, t0 });
+        },
+        onTouchMove: (e) => {
+          const x = e.touches[0].clientX;
+          const t = Date.now();
+          events.moveSwipeBack({ x, t });
+        },
+        onTouchEnd: () => {
+          events.endSwipeBack({});
+        },
+        onTouchCancel: () => {
+          events.endSwipeBack({});
+        }
+      }
+    }),
+    [events]
+  );
+}
+
+export { useSwipeBack };

package/lib/primitive/index.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const AppScreen = require('./AppScreen/AppScreen.cjs');
+const AppScreen_namespace = require('./AppScreen/AppScreen.namespace.cjs');
+const useAppScreenContext = require('./AppScreen/useAppScreenContext.cjs');
+const AppBar = require('./AppBar/AppBar.cjs');
+const AppBar_namespace = require('./AppBar/AppBar.namespace.cjs');
+const GlobalInteraction = require('./GlobalInteraction/GlobalInteraction.cjs');
+const useGlobalInteractionContext = require('./GlobalInteraction/useGlobalInteractionContext.cjs');
+
+
+
+exports.AppScreenDim = AppScreen.AppScreenDim;
+exports.AppScreenEdge = AppScreen.AppScreenEdge;
+exports.AppScreenLayer = AppScreen.AppScreenLayer;
+exports.AppScreenRoot = AppScreen.AppScreenRoot;
+exports.AppScreen = AppScreen_namespace;
+exports.useAppScreenContext = useAppScreenContext.useAppScreenContext;
+exports.AppBarLeft = AppBar.AppBarLeft;
+exports.AppBarMain = AppBar.AppBarMain;
+exports.AppBarRight = AppBar.AppBarRight;
+exports.AppBarRoot = AppBar.AppBarRoot;
+exports.AppBar = AppBar_namespace;
+exports.GlobalInteraction = GlobalInteraction.GlobalInteraction;
+exports.useGlobalInteractionContext = useGlobalInteractionContext.useGlobalInteractionContext;

package/lib/primitive/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./AppScreen";
-export * from "./AppBar";
-export * from "./GlobalInteraction";
+export * from './AppScreen';
+export * from './AppBar';
+export * from './GlobalInteraction';