@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/chunk-Bpi2tz-6.d.ts

@@ -0,0 +1,511 @@
+import { CleanupCallback } from "@aussieljk/forkbook/internal/csf";
+import { Channel } from "@aussieljk/forkbook/internal/channels";
+import { Args as Args$1, CSFFile, ComponentTitle, DecoratorApplicator, GlobalTypes, Globals as Globals$1, IndexEntry, ModuleExport, ModuleExports, ModuleImportFn, NormalizedComponentAnnotations, NormalizedProjectAnnotations, NormalizedStoryAnnotations, Path, PreparedMeta, PreparedStory, ProjectAnnotations as ProjectAnnotations$1, RenderContextCallbacks, RenderToCanvas, Renderer as Renderer$1, StoryContext as StoryContext$1, StoryContextForEnhancers, StoryId as StoryId$1, StoryIndex, StoryName, StoryRenderOptions } from "@aussieljk/forkbook/internal/types";
+
+//#region .dts-emit/code/core/src/preview-api/modules/addons/hooks.d.ts
+interface Hook {
+  name: string;
+  memoizedState?: any;
+  deps?: any[] | undefined;
+}
+interface Effect {
+  create: () => (() => void) | void;
+  destroy?: (() => void) | void;
+}
+type AbstractFunction = (...args: any[]) => any;
+declare class HooksContext<TRenderer extends Renderer$1, TArgs extends Args$1 = Args$1> {
+  hookListsMap: WeakMap<AbstractFunction, Hook[]>;
+  mountedDecorators: Set<AbstractFunction>;
+  prevMountedDecorators: Set<AbstractFunction>;
+  currentHooks: Hook[];
+  nextHookIndex: number;
+  currentPhase: 'MOUNT' | 'UPDATE' | 'NONE';
+  currentEffects: Effect[];
+  prevEffects: Effect[];
+  currentDecoratorName: string | null;
+  hasUpdates: boolean;
+  currentContext: StoryContext$1<TRenderer, TArgs> | null;
+  renderListener: (storyId: StoryId$1) => void;
+  constructor();
+  init(): void;
+  clean(): void;
+  getNextHook(): Hook;
+  triggerEffects(): void;
+  addRenderListeners(): void;
+  removeRenderListeners(): void;
+}
+declare const applyHooks: <TRenderer extends Renderer$1>(applyDecorators: DecoratorApplicator<TRenderer>) => DecoratorApplicator<TRenderer>;
+/**
+ * Returns a memoized value.
+ *
+ * @example
+ *
+ * ```ts
+ * const memoizedValue = useMemo(() => {
+ *   return doExpensiveCalculation(a, b);
+ * }, [a, b]);
+ * ```
+ *
+ * @template T The type of the memoized value.
+ * @param {() => T} nextCreate A function that returns the memoized value.
+ * @param {any[]} [deps] An optional array of dependencies. If any of the dependencies change, the
+ *   memoized value will be recomputed.
+ * @returns {T} The memoized value.
+ */
+declare function useMemo<T>(nextCreate: () => T, deps?: any[]): T;
+/**
+ * Returns a memoized callback.
+ *
+ * @example
+ *
+ * ```ts
+ * const memoizedCallback = useCallback(() => {
+ *   doSomething(a, b);
+ * }, [a, b]);
+ * ```
+ *
+ * @template T The type of the callback function.
+ * @param {T} callback The callback function to memoize.
+ * @param {any[]} [deps] An optional array of dependencies. If any of the dependencies change, the
+ *   memoized callback will be recomputed.
+ * @returns {T} The memoized callback.
+ */
+declare function useCallback<T>(callback: T, deps?: any[]): T;
+/**
+ * Returns a mutable ref object.
+ *
+ * @example
+ *
+ * ```ts
+ * const ref = useRef(0);
+ * ref.current = 1;
+ * ```
+ *
+ * @template T The type of the ref object.
+ * @param {T} initialValue The initial value of the ref object.
+ * @returns {{ current: T }} The mutable ref object.
+ */
+declare function useRef<T>(initialValue: T): {
+  current: T;
+};
+/**
+ * Returns a stateful value and a function to update it.
+ *
+ * @example
+ *
+ * ```ts
+ * const [count, setCount] = useState(0);
+ * setCount(count + 1);
+ * ```
+ *
+ * @template S The type of the state.
+ * @param {(() => S) | S} initialState The initial state value or a function that returns the
+ *   initial state value.
+ * @returns {[S, (update: ((prevState: S) => S) | S) => void]} An array containing the current state
+ *   value and a function to update it.
+ */
+declare function useState<S>(initialState: (() => S) | S): [S, (update: ((prevState: S) => S) | S) => void];
+/**
+ * Given a file name, creates an object with utilities to manage a log file. It creates a temporary
+ * log file which you can manage with the returned functions. You can then decide whether to move
+ * the log file to the users project, or remove it.
+ *
+ * @example
+ *
+ * ```tsx
+ *   const initialState = { count: 0 };
+ *
+ *   function reducer(state, action) {
+ *     switch (action.type) {
+ *       case 'increment':
+ *         return { count: state.count + 1 };
+ *       case 'decrement':
+ *         return { count: state.count - 1 };
+ *       default:
+ *         throw new Error();
+ *       }
+ *     }
+ *   }
+ *   function Counter() {
+ *     const [state, dispatch] = useReducer(reducer, initialState);
+ *     return (
+ *       <>
+ *         Count: {state.count}
+ *           <button onClick={() => dispatch({ type: 'increment' })}>+</button>
+ *           <button onClick={() => dispatch({ type: 'decrement' })}>-</button>
+ *       </>
+ *     );
+ *   }
+ * ```
+ */
+declare function useReducer<S, A>(reducer: (state: S, action: A) => S, initialState: S): [S, (action: A) => void];
+declare function useReducer<S, I, A>(reducer: (state: S, action: A) => S, initialArg: I, init: (initialArg: I) => S): [S, (action: A) => void];
+/**
+ * Triggers a side effect, see https://reactjs.org/docs/hooks-reference.html#usestate Effects are
+ * triggered synchronously after rendering the story
+ *
+ * @example
+ *
+ * ```ts
+ * useEffect(() => {
+ *   // Do something after rendering the story
+ *   return () => {
+ *     // Do something when the component unmounts or the effect is re-run
+ *   };
+ * }, [dependency1, dependency2]);
+ * ```
+ *
+ * @param {() => (() => void) | void} create A function that creates the effect. It should return a
+ *   cleanup function, or nothing.
+ * @param {any[]} [deps] An optional array of dependencies. If any of the dependencies change, the
+ *   effect will be re-run.
+ * @returns {void}
+ */
+declare function useEffect(create: () => (() => void) | void, deps?: any[]): void;
+interface Listener$1 {
+  (...args: any[]): void;
+}
+interface EventMap {
+  [eventId: string]: Listener$1;
+}
+/**
+ * Subscribes to events emitted by the Forkbook channel and returns a function to emit events.
+ *
+ * @example
+ *
+ * ```ts
+ * // Subscribe to an event and emit it
+ * const emit = useChannel({ 'my-event': (arg1, arg2) => console.log(arg1, arg2) });
+ * emit('my-event', 'Hello', 'world!');
+ * ```
+ *
+ * @param {EventMap} eventMap A map of event listeners to subscribe to.
+ * @param {any[]} [deps=[]] An optional array of dependencies. If any of the dependencies change,
+ *   the event listeners will be re-subscribed. Default is `[]`
+ * @returns {(...args: any[]) => void} A function to emit events to the Forkbook channel.
+ */
+declare function useChannel(eventMap: EventMap, deps?: any[]): (eventName: string, ...args: any) => void;
+/**
+ * Returns the current story context, including the story's ID, parameters, and other metadata.
+ *
+ * @example
+ *
+ * ```ts
+ * const { id, parameters } = useStoryContext();
+ * console.log(`Current story ID: ${id}`);
+ * console.log(`Current story parameters: ${JSON.stringify(parameters)}`);
+ * ```
+ *
+ * @template TRenderer The type of the story's renderer.
+ * @template TArgs The type of the story's args.
+ * @returns {StoryContext<TRenderer>} The current story context.
+ */
+declare function useStoryContext<TRenderer extends Renderer$1, TArgs extends Args$1 = Args$1>(): StoryContext$1<TRenderer>;
+/**
+ * Returns the value of a specific parameter for the current story, or a default value if the
+ * parameter is not set.
+ *
+ * @example
+ *
+ * ```ts
+ * // Retrieve the value of a parameter named "myParam"
+ * const myParamValue = useParameter<string>('myParam', 'default value');
+ * console.log(`The value of myParam is: ${myParamValue}`);
+ * ```
+ *
+ * @template S The type of the parameter value.
+ * @param {string} parameterKey The key of the parameter to retrieve.
+ * @param {S} [defaultValue] An optional default value to return if the parameter is not set.
+ * @returns {S | undefined} The value of the parameter, or the default value if the parameter is not
+ *   set.
+ */
+declare function useParameter<S>(parameterKey: string, defaultValue?: S): S | undefined;
+/**
+ * Returns the current args for the story, and functions to update and reset them.
+ *
+ * @example
+ *
+ * ```ts
+ * const [args, updateArgs, resetArgs] = useArgs<{ name: string; age: number }>();
+ * console.log(`Current args: ${JSON.stringify(args)}`);
+ * updateArgs({ name: 'John' });
+ * resetArgs(['name']);
+ * ```
+ *
+ * @template TArgs The type of the story's args.
+ * @returns {[TArgs, (newArgs: Partial<TArgs>) => void, (argNames?: (keyof TArgs)[]) => void]} An
+ *   array containing the current args, a function to update them, and a function to reset them.
+ */
+declare function useArgs<TArgs extends Args$1 = Args$1>(): [TArgs, (newArgs: Partial<TArgs>) => void, (argNames?: (keyof TArgs)[]) => void];
+/**
+ * Returns the current global args for the story, and a function to update them.
+ *
+ * @example
+ *
+ * ```ts
+ * const [globals, updateGlobals] = useGlobals();
+ * console.log(`Current globals: ${JSON.stringify(globals)}`);
+ * updateGlobals({ theme: 'dark' });
+ * ```
+ *
+ * @returns {[Args, (newGlobals: Args) => void]} An array containing the current global args, and a
+ *   function to update them.
+ */
+declare function useGlobals(): [Args$1, (newGlobals: Args$1) => void];
+//#endregion
+//#region .dts-emit/code/core/src/preview-api/modules/store/ArgsStore.d.ts
+declare class ArgsStore {
+  initialArgsByStoryId: Record<StoryId$1, Args$1>;
+  argsByStoryId: Record<StoryId$1, Args$1>;
+  get(storyId: StoryId$1): Args$1;
+  setInitial(story: PreparedStory<any>): void;
+  updateFromDelta(story: PreparedStory<any>, delta: Args$1): void;
+  updateFromPersisted(story: PreparedStory<any>, persisted: Args$1): void;
+  update(storyId: StoryId$1, argsUpdate: Partial<Args$1>): void;
+}
+//#endregion
+//#region .dts-emit/code/core/src/preview-api/modules/store/GlobalsStore.d.ts
+declare class GlobalsStore {
+  allowedGlobalNames: Set<string>;
+  initialGlobals: Globals$1;
+  globals: Globals$1;
+  constructor({
+    globals,
+    globalTypes
+  }: {
+    globals?: Globals$1;
+    globalTypes?: GlobalTypes;
+  });
+  set({
+    globals,
+    globalTypes
+  }: {
+    globals?: Globals$1;
+    globalTypes?: GlobalTypes;
+  }): void;
+  filterAllowedGlobals(globals: Globals$1): Globals$1;
+  updateFromPersisted(persisted: Globals$1): void;
+  get(): Globals$1;
+  update(newGlobals: Globals$1): void;
+}
+//#endregion
+//#region .dts-emit/code/core/src/preview-api/modules/store/StoryIndexStore.d.ts
+type StorySpecifier = StoryId$1 | {
+  name: StoryName;
+  title: ComponentTitle;
+} | '*';
+declare class StoryIndexStore {
+  entries: StoryIndex['entries'];
+  constructor({
+    entries
+  }?: StoryIndex);
+  entryFromSpecifier(specifier: StorySpecifier): IndexEntry | undefined;
+  storyIdToEntry(storyId: StoryId$1): IndexEntry;
+  importPathToEntry(importPath: Path): IndexEntry;
+}
+//#endregion
+//#region .dts-emit/code/core/src/preview-api/modules/store/csf/processCSFFile.d.ts
+declare function processCSFFile<TRenderer extends Renderer$1>(moduleExports: ModuleExports, importPath: Path, title: ComponentTitle): CSFFile<TRenderer>;
+//#endregion
+//#region .dts-emit/code/core/src/preview-api/modules/store/csf/prepareStory.d.ts
+declare function prepareStory<TRenderer extends Renderer$1>(storyAnnotations: NormalizedStoryAnnotations<TRenderer>, componentAnnotations: NormalizedComponentAnnotations<TRenderer>, projectAnnotations: NormalizedProjectAnnotations<TRenderer>): PreparedStory<TRenderer>;
+declare function prepareMeta<TRenderer extends Renderer$1>(componentAnnotations: NormalizedComponentAnnotations<TRenderer>, projectAnnotations: NormalizedProjectAnnotations<TRenderer>, moduleExport: ModuleExport): PreparedMeta<TRenderer>;
+//#endregion
+//#region .dts-emit/code/core/src/preview-api/modules/store/reporter-api.d.ts
+interface Report<T = unknown> {
+  type: string;
+  version?: number;
+  result: T;
+  status: 'failed' | 'passed' | 'warning';
+}
+declare class ReporterAPI {
+  reports: Report[];
+  addReport(report: Report): Promise<void>;
+}
+//#endregion
+//#region .dts-emit/code/core/src/preview-api/modules/store/StoryStore.d.ts
+declare class StoryStore<TRenderer extends Renderer$1> {
+  importFn: ModuleImportFn;
+  storyIndex: StoryIndexStore;
+  projectAnnotations: NormalizedProjectAnnotations<TRenderer>;
+  userGlobals: GlobalsStore;
+  args: ArgsStore;
+  hooks: Record<StoryId$1, HooksContext<TRenderer>>;
+  cleanupCallbacks: Record<StoryId$1, CleanupCallback[] | undefined>;
+  cachedCSFFiles?: Record<Path, CSFFile<TRenderer>>;
+  processCSFFileWithCache: typeof processCSFFile;
+  prepareMetaWithCache: typeof prepareMeta;
+  prepareStoryWithCache: typeof prepareStory;
+  constructor(storyIndex: StoryIndex, importFn: ModuleImportFn, projectAnnotations: ProjectAnnotations$1<TRenderer>);
+  setProjectAnnotations(projectAnnotations: ProjectAnnotations$1<TRenderer>): void;
+  onStoriesChanged({
+    importFn,
+    storyIndex
+  }: {
+    importFn?: ModuleImportFn;
+    storyIndex?: StoryIndex;
+  }): Promise<void>;
+  storyIdToEntry(storyId: StoryId$1): Promise<IndexEntry>;
+  loadCSFFileByStoryId(storyId: StoryId$1): Promise<CSFFile<TRenderer>>;
+  loadAllCSFFiles(): Promise<StoryStore<TRenderer>['cachedCSFFiles']>;
+  cacheAllCSFFiles(): Promise<void>;
+  preparedMetaFromCSFFile({
+    csfFile
+  }: {
+    csfFile: CSFFile<TRenderer>;
+  }): PreparedMeta<TRenderer>;
+  loadStory({
+    storyId
+  }: {
+    storyId: StoryId$1;
+  }): Promise<PreparedStory<TRenderer>>;
+  storyFromCSFFile({
+    storyId,
+    csfFile
+  }: {
+    storyId: StoryId$1;
+    csfFile: CSFFile<TRenderer>;
+  }): PreparedStory<TRenderer>;
+  componentStoriesFromCSFFile({
+    csfFile
+  }: {
+    csfFile: CSFFile<TRenderer>;
+  }): PreparedStory<TRenderer>[];
+  loadEntry(id: StoryId$1): Promise<{
+    entryExports: ModuleExports;
+    csfFiles: CSFFile<TRenderer>[];
+  }>;
+  getStoryContext(story: PreparedStory<TRenderer>, {
+    forceInitialArgs
+  }?: {
+    forceInitialArgs?: boolean | undefined;
+  }): {
+    args: import("@aussieljk/forkbook/internal/csf").Args;
+    initialGlobals: import("@aussieljk/forkbook/internal/csf").Globals;
+    globalTypes: import("@aussieljk/forkbook/internal/csf").GlobalTypes | undefined;
+    userGlobals: import("@aussieljk/forkbook/internal/csf").Globals;
+    reporting: ReporterAPI;
+    globals: {
+      [x: string]: any;
+    };
+    hooks: unknown;
+    componentId: import("@aussieljk/forkbook/internal/csf").ComponentId;
+    title: import("@aussieljk/forkbook/internal/csf").ComponentTitle;
+    kind: import("@aussieljk/forkbook/internal/csf").ComponentTitle;
+    id: StoryId$1;
+    name: import("@aussieljk/forkbook/internal/csf").StoryName;
+    story: import("@aussieljk/forkbook/internal/csf").StoryName;
+    tags: import("@aussieljk/forkbook/internal/csf").Tag[];
+    component?: (TRenderer & {
+      T: any;
+    })["component"] | undefined;
+    subcomponents?: Record<string, (TRenderer & {
+      T: any;
+    })["component"]> | undefined;
+    parameters: import("@aussieljk/forkbook/internal/csf").Parameters;
+    initialArgs: import("@aussieljk/forkbook/internal/csf").Args;
+    argTypes: import("@aussieljk/forkbook/internal/csf").StrictArgTypes<import("@aussieljk/forkbook/internal/csf").Args>;
+    moduleExport: import("@aussieljk/forkbook/internal/types").ModuleExport;
+    originalStoryFn: import("@aussieljk/forkbook/internal/csf").ArgsStoryFn<TRenderer>;
+    undecoratedStoryFn: import("@aussieljk/forkbook/internal/csf").LegacyStoryFn<TRenderer>;
+    unboundStoryFn: import("@aussieljk/forkbook/internal/csf").LegacyStoryFn<TRenderer>;
+    applyLoaders: (context: import("@aussieljk/forkbook/internal/csf").StoryContext<TRenderer, import("@aussieljk/forkbook/internal/csf").Args>) => Promise<import("@aussieljk/forkbook/internal/csf").StoryContext<TRenderer>['loaded']>;
+    applyBeforeEach: (context: import("@aussieljk/forkbook/internal/csf").StoryContext<TRenderer, import("@aussieljk/forkbook/internal/csf").Args>) => Promise<CleanupCallback[]>;
+    applyAfterEach: (context: import("@aussieljk/forkbook/internal/csf").StoryContext<TRenderer, import("@aussieljk/forkbook/internal/csf").Args>) => Promise<void>;
+    playFunction?: ((context: import("@aussieljk/forkbook/internal/csf").StoryContext<TRenderer, import("@aussieljk/forkbook/internal/csf").Args>) => Promise<void> | void) | undefined;
+    runStep: import("@aussieljk/forkbook/internal/csf").StepRunner<TRenderer>;
+    mount: (context: import("@aussieljk/forkbook/internal/csf").StoryContext<TRenderer, import("@aussieljk/forkbook/internal/csf").Args>) => () => Promise<import("@aussieljk/forkbook/internal/csf").Canvas>;
+    testingLibraryRender?: (...args: never[]) => unknown;
+    renderToCanvas?: import("@aussieljk/forkbook/internal/types").RenderToCanvas<TRenderer> | undefined;
+    usesMount: boolean;
+    storyGlobals: import("@aussieljk/forkbook/internal/csf").Globals;
+  } & Pick<import("@aussieljk/forkbook/internal/csf").StoryContextForRender<Renderer$1, import("@aussieljk/forkbook/internal/csf").Args>, "allArgs" | "argsByTarget" | "unmappedArgs">;
+  addCleanupCallbacks(story: PreparedStory<TRenderer>, ...callbacks: CleanupCallback[]): void;
+  cleanupStory(story: PreparedStory<TRenderer>): Promise<void>;
+  extract(options?: {
+    includeDocsOnly?: boolean;
+  }): Record<StoryId$1, StoryContextForEnhancers<TRenderer>>;
+}
+//#endregion
+//#region .dts-emit/code/core/src/preview-api/modules/preview-web/render/Render.d.ts
+type RenderType = 'story' | 'docs';
+/**
+ * A "Render" represents the rendering of a single entry to a single location
+ *
+ * The implementations of render are used for two key purposes:
+ *
+ * - Tracking the state of the rendering as it moves between preparing, rendering and tearing down.
+ * - Tracking what is rendered to know if a change requires re-rendering or teardown + recreation.
+ */
+interface Render<TRenderer extends Renderer$1> {
+  renderId: number;
+  type: RenderType;
+  id: StoryId$1;
+  isPreparing: () => boolean;
+  isEqual: (other: Render<TRenderer>) => boolean;
+  disableKeyListeners: boolean;
+  teardown?: (options: {
+    viewModeChanged: boolean;
+    keepRenderedDom?: boolean;
+  }) => Promise<void>;
+  torndown: boolean;
+  renderToElement: (canvasElement: TRenderer['canvasElement'], renderStoryToElement?: any, options?: StoryRenderOptions) => Promise<void>;
+}
+//#endregion
+//#region .dts-emit/code/core/src/preview-api/modules/preview-web/render/StoryRender.d.ts
+type RenderPhase = 'preparing' | 'loading' | 'beforeEach' | 'rendering' | 'playing' | 'played' | 'completing' | 'completed' | 'afterEach' | 'finished' | 'aborted' | 'errored';
+declare class StoryRender<TRenderer extends Renderer$1> implements Render<TRenderer> {
+  channel: Channel;
+  store: StoryStore<TRenderer>;
+  private renderToScreen;
+  private callbacks;
+  id: StoryId$1;
+  viewMode: StoryContext$1<TRenderer>['viewMode'];
+  renderOptions: StoryRenderOptions;
+  readonly renderId: number;
+  type: RenderType;
+  story?: PreparedStory<TRenderer>;
+  phase?: RenderPhase;
+  private abortController;
+  private canvasElement?;
+  private notYetRendered;
+  private rerenderEnqueued;
+  disableKeyListeners: boolean;
+  private teardownRender;
+  torndown: boolean;
+  constructor(channel: Channel, store: StoryStore<TRenderer>, renderToScreen: RenderToCanvas<TRenderer>, callbacks: RenderContextCallbacks<TRenderer> & {
+    showStoryDuringRender?: () => void;
+  }, id: StoryId$1, viewMode: StoryContext$1<TRenderer>['viewMode'], renderOptions?: StoryRenderOptions, story?: PreparedStory<TRenderer>);
+  private runPhase;
+  private checkIfAborted;
+  prepare(): Promise<void>;
+  isEqual(other: Render<TRenderer>): boolean;
+  isPreparing(): boolean;
+  isPending(): boolean;
+  renderToElement(canvasElement: TRenderer['canvasElement']): Promise<void>;
+  private storyContext;
+  render({
+    initial,
+    forceRemount
+  }?: {
+    initial?: boolean;
+    forceRemount?: boolean;
+  }): Promise<void>;
+  /**
+   * Rerender the story. If the story is currently pending (loading/rendering), the rerender will be
+   * enqueued, and will be executed after the current render is completed. Rerendering while playing
+   * will not be enqueued, and will be executed immediately, to support rendering args changes while
+   * playing.
+   */
+  rerender(): Promise<void>;
+  remount(): Promise<void>;
+  cancelRender(): void;
+  cancelPlayFunction(): void;
+  teardown({
+    keepRenderedDom
+  }?: {
+    keepRenderedDom?: boolean;
+  }): Promise<void>;
+}
+//#endregion
+export { useStoryContext as C, useState as S, useGlobals as _, StoryStore as a, useReducer as b, prepareMeta as c, HooksContext as d, applyHooks as f, useEffect as g, useChannel as h, RenderType as i, prepareStory as l, useCallback as m, StoryRender as n, Report as o, useArgs as p, Render as r, ReporterAPI as s, RenderPhase as t, StorySpecifier as u, useMemo as v, useRef as x, useParameter as y };

package/dist/chunk-BxWufQms.d.ts

@@ -0,0 +1,142 @@
+import * as React$2 from "react";
+import * as RN from "react-native";
+
+//#region ../../node_modules/@emotion/react/dist/declarations/src/types.d.ts
+/**
+ * @desc Utility type for getting props type of React component.
+ * It takes `defaultProps` into an account - making props with defaults optional.
+ */
+type PropsOf<C extends keyof ReactJSX.IntrinsicElements | React.JSXElementConstructor<any>> = ReactJSX.LibraryManagedAttributes<C, React.ComponentProps<C>>;
+type DistributiveOmit<T, U> = T extends any ? Pick<T, Exclude<keyof T, U>> : never;
+//#endregion
+//#region ../../node_modules/@emotion/react/dist/declarations/src/theming.d.ts
+interface Theme {}
+interface ThemeProviderProps {
+  theme: Partial<Theme> | ((outerTheme: Theme) => Theme);
+  children: React$2.ReactNode;
+}
+interface ThemeProvider {
+  (props: ThemeProviderProps): React$2.ReactElement;
+}
+declare const useTheme: () => Theme;
+interface ThemeProviderProps {
+  theme: Partial<Theme> | ((outerTheme: Theme) => Theme);
+  children: React$2.ReactNode;
+}
+declare const ThemeProvider: (props: ThemeProviderProps) => React$2.JSX.Element;
+declare function withTheme<C extends React$2.ComponentType<React$2.ComponentProps<C>>>(Component: C): React$2.ForwardRefExoticComponent<DistributiveOmit<PropsOf<C>, 'theme'> & {
+  theme?: Theme;
+}>;
+//#endregion
+//#region ../../node_modules/@emotion/react/dist/declarations/src/jsx-namespace.d.ts
+type IsPreReact19 = 2 extends Parameters<React.FunctionComponent<any>>['length'] ? true : false;
+/** @ts-ignore */
+type ReactJSXElement = true extends IsPreReact19 ? JSX.Element : React.JSX.Element;
+/** @ts-ignore */
+type ReactJSXElementClass = true extends IsPreReact19 ? JSX.ElementClass : React.JSX.ElementClass;
+/** @ts-ignore */
+type ReactJSXElementAttributesProperty = true extends IsPreReact19 ? JSX.ElementAttributesProperty : React.JSX.ElementAttributesProperty;
+/** @ts-ignore */
+type ReactJSXElementChildrenAttribute = true extends IsPreReact19 ? JSX.ElementChildrenAttribute : React.JSX.ElementChildrenAttribute;
+/** @ts-ignore */
+type ReactJSXLibraryManagedAttributes<C, P> = true extends IsPreReact19 ? JSX.LibraryManagedAttributes<C, P> : React.JSX.LibraryManagedAttributes<C, P>;
+/** @ts-ignore */
+type ReactJSXIntrinsicAttributes = true extends IsPreReact19 ? JSX.IntrinsicAttributes : React.JSX.IntrinsicAttributes;
+/** @ts-ignore */
+type ReactJSXIntrinsicClassAttributes<T> = true extends IsPreReact19 ? JSX.IntrinsicClassAttributes<T> : React.JSX.IntrinsicClassAttributes<T>;
+/** @ts-ignore */
+type ReactJSXIntrinsicElements = true extends IsPreReact19 ? JSX.IntrinsicElements : React.JSX.IntrinsicElements;
+/** @ts-ignore */
+type ReactJSXElementType = true extends IsPreReact19 ? string | React.JSXElementConstructor<any> : React.JSX.ElementType;
+declare namespace ReactJSX {
+  type ElementType = ReactJSXElementType;
+  interface Element extends ReactJSXElement {}
+  interface ElementClass extends ReactJSXElementClass {}
+  interface ElementAttributesProperty extends ReactJSXElementAttributesProperty {}
+  interface ElementChildrenAttribute extends ReactJSXElementChildrenAttribute {}
+  type LibraryManagedAttributes<C, P> = ReactJSXLibraryManagedAttributes<C, P>;
+  interface IntrinsicAttributes extends ReactJSXIntrinsicAttributes {}
+  interface IntrinsicClassAttributes<T> extends ReactJSXIntrinsicClassAttributes<T> {}
+  type IntrinsicElements = ReactJSXIntrinsicElements;
+}
+//#endregion
+//#region ../../node_modules/@emotion/native/dist/declarations/types/base.d.ts
+type ReactNativeStyle = RN.ViewStyle | RN.TextStyle | RN.ImageStyle;
+type ReactNativeStyleType<Props> = Props extends {
+  style?: RN.StyleProp<infer StyleType>;
+} ? StyleType extends ReactNativeStyle ? StyleType : ReactNativeStyle : ReactNativeStyle;
+type InterpolationPrimitive<StyleType extends ReactNativeStyle = ReactNativeStyle> = null | undefined | boolean | number | string | ObjectInterpolation<StyleType>;
+type ObjectInterpolation<StyleType extends ReactNativeStyle = ReactNativeStyle> = StyleType;
+interface ArrayInterpolation<MergedProps, StyleType extends ReactNativeStyle = ReactNativeStyle> extends Array<Interpolation<MergedProps, StyleType>> {}
+interface FunctionInterpolation<MergedProps, StyleType extends ReactNativeStyle = ReactNativeStyle> {
+  (mergedProps: MergedProps): Interpolation<MergedProps, StyleType>;
+}
+type Interpolation<MergedProps = unknown, StyleType extends ReactNativeStyle = ReactNativeStyle> = InterpolationPrimitive<StyleType> | ArrayInterpolation<MergedProps, StyleType> | FunctionInterpolation<MergedProps, StyleType>;
+/** Same as StyledOptions but shouldForwardProp must be a type guard */
+interface FilteringStyledOptions<Props = Record<string, any>, ForwardedProps extends keyof Props & string = keyof Props & string> {
+  shouldForwardProp?: (propName: string) => propName is ForwardedProps;
+}
+interface StyledOptions<Props = Record<string, any>> {
+  shouldForwardProp?: (propName: string) => boolean;
+}
+/**
+ * @typeparam ComponentProps  Props which will be included when withComponent is called
+ * @typeparam SpecificComponentProps  Props which will *not* be included when withComponent is called
+ */
+interface StyledComponent<ComponentProps extends {}, SpecificComponentProps extends {} = {}, JSXProps extends {} = {}> extends React.FC<ComponentProps & SpecificComponentProps & JSXProps> {
+  withComponent<C extends React.ComponentClass<React.ComponentProps<C>>>(component: C): StyledComponent<ComponentProps & React.ComponentProps<C>, {}, {
+    ref?: React.Ref<InstanceType<C>>;
+  }>;
+  withComponent<C extends React.ComponentType<React.ComponentProps<C>>>(component: C): StyledComponent<ComponentProps & React.ComponentProps<C>>;
+}
+/**
+ * @typeparam ComponentProps  Props which will be included when withComponent is called
+ * @typeparam SpecificComponentProps  Props which will *not* be included when withComponent is called
+ */
+interface CreateStyledComponent<ComponentProps extends {}, SpecificComponentProps extends {} = {}, JSXProps extends {} = {}, StyleType extends ReactNativeStyle = ReactNativeStyle> {
+  /**
+   * @typeparam AdditionalProps  Additional props to add to your styled component
+   */
+  <AdditionalProps extends {} = {}>(...styles: ArrayInterpolation<ComponentProps & SpecificComponentProps & AdditionalProps & {
+    theme: Theme;
+  }, StyleType>): StyledComponent<ComponentProps & AdditionalProps, SpecificComponentProps, JSXProps>;
+  /**
+   * @typeparam AdditionalProps  Additional props to add to your styled component
+   */
+  <AdditionalProps extends {} = {}>(template: TemplateStringsArray, ...styles: ArrayInterpolation<ComponentProps & SpecificComponentProps & AdditionalProps & {
+    theme: Theme;
+  }, StyleType>): StyledComponent<ComponentProps & AdditionalProps, SpecificComponentProps, JSXProps>;
+}
+/**
+ * @desc
+ * This function accepts a React component.
+ *
+ * @example styled(MyComponent)({ width: 100 })
+ * @example styled(MyComponent)(myComponentProps => ({ width: myComponentProps.width })
+ * @example styled(View)({ width: 100 })
+ * @example styled(View)<Props>(props => ({ width: props.width })
+ */
+interface CreateStyled {
+  <C extends React.ComponentClass<React.ComponentProps<C>>, ForwardedProps extends keyof React.ComponentProps<C> & string = keyof React.ComponentProps<C> & string>(component: C, options: FilteringStyledOptions<React.ComponentProps<C>, ForwardedProps>): CreateStyledComponent<Pick<React.ComponentProps<C>, ForwardedProps> & {
+    theme?: Theme;
+    as?: React.ElementType;
+  }, {}, {
+    ref?: React.Ref<InstanceType<C>>;
+  }, ReactNativeStyleType<React.ComponentProps<C>>>;
+  <C extends React.ComponentClass<React.ComponentProps<C>>>(component: C, options?: StyledOptions<React.ComponentProps<C>>): CreateStyledComponent<React.ComponentProps<C> & {
+    theme?: Theme;
+    as?: React.ElementType;
+  }, {}, {
+    ref?: React.Ref<InstanceType<C>>;
+  }, ReactNativeStyleType<React.ComponentProps<C>>>;
+  <C extends React.ComponentType<React.ComponentProps<C>>, ForwardedProps extends keyof React.ComponentProps<C> & string = keyof React.ComponentProps<C> & string>(component: C, options: FilteringStyledOptions<React.ComponentProps<C>, ForwardedProps>): CreateStyledComponent<Pick<React.ComponentProps<C>, ForwardedProps> & {
+    theme?: Theme;
+    as?: React.ElementType;
+  }, {}, {}, ReactNativeStyleType<React.ComponentProps<C>>>;
+  <C extends React.ComponentType<React.ComponentProps<C>>>(component: C, options?: StyledOptions<React.ComponentProps<C>>): CreateStyledComponent<React.ComponentProps<C> & {
+    theme?: Theme;
+    as?: React.ElementType;
+  }, {}, {}, ReactNativeStyleType<React.ComponentProps<C>>>;
+}
+//#endregion
+export { Theme as a, withTheme as c, StyledComponent as i, CreateStyledComponent as n, ThemeProvider as o, ReactNativeStyleType as r, useTheme as s, CreateStyled as t };