@cedarjs/web 0.0.4

package/dist/components/cell/createServerCell.js

@@ -0,0 +1,57 @@
+import React, { Suspense } from "react";
+import { isDataEmpty } from "./isCellEmpty.js";
+function createServerCell(createCellProps) {
+  const {
+    data: dataFn,
+    isEmpty = isDataEmpty,
+    Loading,
+    Failure,
+    Empty,
+    Success,
+    displayName = "Cell"
+  } = createCellProps;
+  async function SuspendingSuccess(props) {
+    const { children: _, ...variables } = props;
+    const FailureComponent = ({ error }) => {
+      if (!Failure) {
+        throw error;
+      }
+      const queryResultWithRefetch = {
+        refetch: (variables2) => {
+          return dataFn(variables2);
+        }
+      };
+      return /* @__PURE__ */ React.createElement(Failure, { error, queryResult: queryResultWithRefetch });
+    };
+    try {
+      const data = await dataFn(variables);
+      if (isEmpty(data, { isDataEmpty }) && Empty) {
+        return /* @__PURE__ */ React.createElement(Empty, { ...props, ...data });
+      }
+      return /* @__PURE__ */ React.createElement(Success, { ...data, ...props });
+    } catch (error) {
+      return /* @__PURE__ */ React.createElement(FailureComponent, { error });
+    }
+  }
+  SuspendingSuccess.displayName = displayName;
+  return (props) => {
+    const wrapInSuspenseIfLoadingPresent = (suspendingSuccessElement, LoadingComponent) => {
+      if (!LoadingComponent) {
+        return suspendingSuccessElement;
+      }
+      return /* @__PURE__ */ React.createElement(Suspense, { fallback: /* @__PURE__ */ React.createElement(LoadingComponent, { ...props }) }, suspendingSuccessElement);
+    };
+    return (
+      // TODO(RSC): Do we always want a client side error boundary? If so, this
+      // is where we'd add it
+      // <CellErrorBoundary renderFallback={FailureComponent}>
+      /* @__PURE__ */ React.createElement(React.Fragment, null, wrapInSuspenseIfLoadingPresent(
+        /* @__PURE__ */ React.createElement(SuspendingSuccess, { ...props }),
+        Loading
+      ))
+    );
+  };
+}
+export {
+  createServerCell
+};

package/dist/components/cell/createSuspendingCell.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { CreateCellProps } from './cellTypes.js';
+type AnyObj = Record<string, unknown>;
+/**
+ * Creates a Cell ~~ with Apollo Client only ~~
+ * using the hooks useBackgroundQuery and useReadQuery
+ *
+ */
+export declare function createSuspendingCell<CellProps extends AnyObj, CellVariables extends AnyObj>(createCellProps: CreateCellProps<AnyObj, CellVariables>): React.FC<CellProps>;
+export {};
+//# sourceMappingURL=createSuspendingCell.d.ts.map

package/dist/components/cell/createSuspendingCell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSuspendingCell.d.ts","sourceRoot":"","sources":["../../../src/components/cell/createSuspendingCell.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAA;AAYvC,OAAO,KAAK,EACV,eAAe,EAIhB,MAAM,gBAAgB,CAAA;AAGvB,KAAK,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AACrC;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,SAAS,MAAM,EACxB,aAAa,SAAS,MAAM,EAE5B,eAAe,EAAE,eAAe,CAAC,MAAM,EAAE,aAAa,CAAC,GACtD,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,CAqIrB"}

package/dist/components/cell/createSuspendingCell.js

@@ -0,0 +1,118 @@
+import React, { Suspense } from "react";
+import { useApolloClient } from "@apollo/client/react/hooks/hooks.cjs";
+import { useBackgroundQuery, useReadQuery } from "../GraphQLHooksProvider.js";
+import { CellErrorBoundary } from "./CellErrorBoundary.js";
+import { isDataEmpty } from "./isCellEmpty.js";
+function createSuspendingCell(createCellProps) {
+  const {
+    QUERY,
+    beforeQuery = (props) => ({
+      // By default, we assume that the props are the gql-variables.
+      variables: props,
+      /**
+       * We're duplicating these props here due to a suspected bug in Apollo Client v3.5.4
+       * (it doesn't seem to be respecting `defaultOptions` in `RedwoodApolloProvider`.)
+       *
+       * @see {@link https://github.com/apollographql/apollo-client/issues/9105}
+       */
+      fetchPolicy: "cache-and-network",
+      notifyOnNetworkStatusChange: true
+    }),
+    afterQuery = (data) => ({ ...data }),
+    isEmpty = isDataEmpty,
+    Loading,
+    Failure,
+    Empty,
+    Success,
+    displayName = "Cell"
+  } = createCellProps;
+  function SuspendingSuccess(props) {
+    const { queryRef, suspenseQueryResult, userProps } = props;
+    const { data, networkStatus } = useReadQuery(queryRef);
+    const afterQueryData = afterQuery(data);
+    const queryResultWithNetworkStatus = {
+      ...suspenseQueryResult,
+      networkStatus
+    };
+    if (isEmpty(data, { isDataEmpty }) && Empty) {
+      return /* @__PURE__ */ React.createElement(
+        Empty,
+        {
+          ...userProps,
+          ...afterQueryData,
+          queryResult: queryResultWithNetworkStatus
+        }
+      );
+    }
+    return /* @__PURE__ */ React.createElement(
+      Success,
+      {
+        ...afterQueryData,
+        ...userProps,
+        queryResult: queryResultWithNetworkStatus
+      }
+    );
+  }
+  SuspendingSuccess.displayName = displayName;
+  return (props) => {
+    const { children: _, ...variables } = props;
+    const options = beforeQuery(variables);
+    const query = typeof QUERY === "function" ? QUERY(options) : QUERY;
+    const [queryRef, other] = useBackgroundQuery(query, options);
+    const client = useApolloClient();
+    const suspenseQueryResult = {
+      client,
+      ...other,
+      called: !!queryRef
+    };
+    const FailureComponent = ({ error, resetErrorBoundary }) => {
+      if (!Failure) {
+        if (error) {
+          throw error;
+        }
+        throw new Error("Unreachable code: FailureComponent without a Failure");
+      }
+      const queryResultWithErrorReset = {
+        ...suspenseQueryResult,
+        refetch: (variables2) => {
+          resetErrorBoundary();
+          return suspenseQueryResult.refetch?.(variables2);
+        }
+      };
+      return /* @__PURE__ */ React.createElement(
+        Failure,
+        {
+          error,
+          errorCode: error?.graphQLErrors?.[0]?.extensions?.["code"],
+          queryResult: queryResultWithErrorReset
+        }
+      );
+    };
+    const wrapInSuspenseIfLoadingPresent = (suspendingSuccessElement, LoadingComponent) => {
+      if (!LoadingComponent) {
+        return suspendingSuccessElement;
+      }
+      return /* @__PURE__ */ React.createElement(
+        Suspense,
+        {
+          fallback: /* @__PURE__ */ React.createElement(LoadingComponent, { ...props, queryResult: suspenseQueryResult })
+        },
+        suspendingSuccessElement
+      );
+    };
+    return /* @__PURE__ */ React.createElement(CellErrorBoundary, { renderFallback: FailureComponent }, wrapInSuspenseIfLoadingPresent(
+      /* @__PURE__ */ React.createElement(
+        SuspendingSuccess,
+        {
+          userProps: props,
+          queryRef,
+          suspenseQueryResult
+        }
+      ),
+      Loading
+    ));
+  };
+}
+export {
+  createSuspendingCell
+};

package/dist/components/cell/createSuspendingCell.test.js

@@ -0,0 +1,92 @@
+import React from "react";
+import { loadErrorMessages, loadDevMessages } from "@apollo/client/dev";
+import { render, screen } from "@testing-library/react";
+import { vi, describe, beforeAll, test } from "vitest";
+import { GraphQLHooksProvider } from "../GraphQLHooksProvider.js";
+import { createSuspendingCell } from "./createSuspendingCell.js";
+vi.mock("@apollo/client/react/hooks/hooks.cjs", () => {
+  return {
+    useApolloClient: vi.fn()
+  };
+});
+describe("createSuspendingCell", () => {
+  beforeAll(() => {
+    globalThis.RWJS_ENV = {
+      RWJS_EXP_STREAMING_SSR: true
+    };
+    loadDevMessages();
+    loadErrorMessages();
+  });
+  const mockedUseBgQuery = () => {
+    return ["mocked-query-ref", { refetch: vi.fn(), fetchMore: vi.fn() }];
+  };
+  const mockedQueryHook = () => ({ data: {} });
+  test("Renders a static Success component", () => {
+    const TestCell = createSuspendingCell({
+      // @ts-expect-error - Purposefully using a plain string here.
+      QUERY: "query TestQuery { answer }",
+      Success: () => /* @__PURE__ */ React.createElement(React.Fragment, null, "Great success!")
+    });
+    render(
+      /* @__PURE__ */ React.createElement(
+        GraphQLHooksProvider,
+        {
+          useBackgroundQuery: mockedUseBgQuery,
+          useReadQuery: mockedQueryHook
+        },
+        /* @__PURE__ */ React.createElement(TestCell, null)
+      )
+    );
+    screen.getByText(/^Great success!$/);
+  });
+  test("Renders Success with data", () => {
+    const TestCell = createSuspendingCell({
+      // @ts-expect-error - Purposefully using a plain string here.
+      QUERY: "query TestQuery { answer }",
+      Success: ({ answer }) => /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("dl", null, /* @__PURE__ */ React.createElement("dt", null, "What's the meaning of life?"), /* @__PURE__ */ React.createElement("dd", null, answer)))
+    });
+    const myUseQueryHook = () => {
+      return { data: { answer: 42 } };
+    };
+    render(
+      /* @__PURE__ */ React.createElement(
+        GraphQLHooksProvider,
+        {
+          useReadQuery: myUseQueryHook,
+          useBackgroundQuery: mockedUseBgQuery
+        },
+        /* @__PURE__ */ React.createElement(TestCell, null)
+      )
+    );
+    screen.getByText(/^What's the meaning of life\?$/);
+    screen.getByText(/^42$/);
+  });
+  test("Renders Success if any of the fields have data (i.e. not just the first)", () => {
+    const TestCell = createSuspendingCell({
+      // @ts-expect-error - Purposefully using a plain string here.
+      QUERY: "query TestQuery { users { name } posts { title } }",
+      Empty: () => /* @__PURE__ */ React.createElement(React.Fragment, null, "No users or posts"),
+      Success: ({ users, posts }) => /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement("div", null, users.length > 0 ? /* @__PURE__ */ React.createElement("ul", null, users.map(({ name }) => /* @__PURE__ */ React.createElement("li", { key: name }, name))) : "no users"), /* @__PURE__ */ React.createElement("div", null, posts.length > 0 ? /* @__PURE__ */ React.createElement("ul", null, posts.map(({ title }) => /* @__PURE__ */ React.createElement("li", { key: title }, title))) : "no posts"))
+    });
+    const myReadQueryHook = () => {
+      return {
+        data: {
+          users: [],
+          posts: [{ title: "bazinga" }, { title: "kittens" }]
+        }
+      };
+    };
+    render(
+      /* @__PURE__ */ React.createElement(
+        GraphQLHooksProvider,
+        {
+          useReadQuery: myReadQueryHook,
+          useBackgroundQuery: mockedUseBgQuery
+        },
+        /* @__PURE__ */ React.createElement(TestCell, null)
+      )
+    );
+    screen.getByText(/bazinga/);
+    screen.getByText(/kittens/);
+  });
+});

package/dist/components/cell/isCellEmpty.d.ts

@@ -0,0 +1,41 @@
+import type { DataObject } from './cellTypes.js';
+/**
+ * The default `isEmpty` implementation checks if any of the fields are `null`
+ * or an empty array.
+ *
+ * Consider the following queries. The former returns an object, the latter a list:
+ *
+ * ```js
+ * export const QUERY = gql`
+ *   post {
+ *     title
+ *   }
+ * `
+ *
+ * export const QUERY = gql`
+ *   posts {
+ *     title
+ *   }
+ * `
+ * ```
+ *
+ * If either are "empty", they return:
+ *
+ * ```js
+ * {
+ *   data: {
+ *     post: null
+ *   }
+ * }
+ *
+ * {
+ *   data: {
+ *     posts: []
+ *   }
+ * }
+ * ```
+ *
+ * Note that the latter can return `null` as well depending on the SDL (`posts: [Post!]`).
+ */
+export declare function isDataEmpty(data?: DataObject): boolean;
+//# sourceMappingURL=isCellEmpty.d.ts.map

package/dist/components/cell/isCellEmpty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCellEmpty.d.ts","sourceRoot":"","sources":["../../../src/components/cell/isCellEmpty.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,WAAW,CAAC,IAAI,CAAC,EAAE,UAAU,WAO5C"}

package/dist/components/cell/isCellEmpty.js

@@ -0,0 +1,11 @@
+function isDataEmpty(data) {
+  return !data || Object.values(data).every((fieldValue) => {
+    return fieldValue === null || isFieldEmptyArray(fieldValue);
+  });
+}
+function isFieldEmptyArray(field) {
+  return Array.isArray(field) && field.length === 0;
+}
+export {
+  isDataEmpty
+};

package/dist/components/htmlTags.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+/** CSS is a specialised metatag */
+export declare const Css: ({ css }: {
+    css: string[];
+}) => React.JSX.Element;
+/**
+ * <title>My Page</title>
+ */
+interface Title {
+    title: string;
+}
+/**
+ * <meta name="author" content="Chris Mills" />
+ */
+interface NameContent {
+    name: string;
+    content: string;
+}
+/**
+ * <meta property="og:image"
+ * content="https://.../opengraph-logo.png" />
+ */
+interface OpenGraph {
+    property: string;
+    content: string;
+}
+/**
+ * <meta http-equiv="refresh" content="30">
+ */
+interface HttpEquiv {
+    httpEquiv: string;
+    content: string;
+}
+/***
+ * <meta some-attribute="some-value" />
+ */
+interface Custom {
+    [name: string]: unknown;
+}
+/**
+ * <link rel="canonical" href="https://example.com" />
+ */
+interface Other extends Custom {
+    tagType: string;
+}
+export type TagDescriptor = Title | NameContent | OpenGraph | HttpEquiv | Custom | Other;
+interface MetaProps {
+    tags: TagDescriptor[] | undefined;
+}
+export declare const Meta: ({ tags }: MetaProps) => React.JSX.Element;
+export {};
+//# sourceMappingURL=htmlTags.d.ts.map

package/dist/components/htmlTags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlTags.d.ts","sourceRoot":"","sources":["../../src/components/htmlTags.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAkCzB,mCAAmC;AACnC,eAAO,MAAM,GAAG,YAAa;IAAE,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,sBAY7C,CAAA;AAED;;GAEG;AACH,UAAU,KAAK;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;GAGG;AACH,UAAU,SAAS;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,UAAU,SAAS;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,UAAU,MAAM;IACd,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;CACxB;AAED;;GAEG;AACH,UAAU,KAAM,SAAQ,MAAM;IAC5B,OAAO,EAAE,MAAM,CAAA;CAChB;AAOD,MAAM,MAAM,aAAa,GACrB,KAAK,GAEL,WAAW,GACX,SAAS,GACT,SAAS,GAET,MAAM,GACN,KAAK,CAAA;AAET,UAAU,SAAS;IACjB,IAAI,EAAE,aAAa,EAAE,GAAG,SAAS,CAAA;CAClC;AAED,eAAO,MAAM,IAAI,aAAc,SAAS,sBA6BvC,CAAA"}

package/dist/components/htmlTags.js

@@ -0,0 +1,53 @@
+import React from "react";
+import { Fragment } from "react";
+const extractCssFromAssetMap = () => {
+  if (typeof window !== "undefined") {
+    return window.__REDWOOD__ASSET_MAP?.css;
+  }
+  return void 0;
+};
+const extractMetaFromAssetMap = () => {
+  if (typeof window !== "undefined") {
+    return window.__REDWOOD__ASSET_MAP?.meta;
+  }
+  return void 0;
+};
+function addSlashIfNeeded(path) {
+  if (path.startsWith("http") || path.startsWith("/")) {
+    return path;
+  } else {
+    return "/" + path;
+  }
+}
+const Css = ({ css }) => {
+  const cssLinks = (css || extractCssFromAssetMap() || []).map(addSlashIfNeeded);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, cssLinks.map((cssLink, index) => {
+    return /* @__PURE__ */ React.createElement("link", { rel: "stylesheet", key: `css-${index}`, href: `${cssLink}` });
+  }));
+};
+const Meta = ({ tags }) => {
+  const metaTags = tags || extractMetaFromAssetMap() || [];
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, metaTags.map((tag, index) => {
+    if (!tag) {
+      return null;
+    }
+    if (isTitleTag(tag)) {
+      return /* @__PURE__ */ React.createElement(Fragment, { key: "title" }, /* @__PURE__ */ React.createElement("title", null, tag.title), /* @__PURE__ */ React.createElement("meta", { property: "og:title", content: tag.title }));
+    }
+    if (otherTag(tag)) {
+      const { tagType: TagName, ...rest } = tag;
+      return /* @__PURE__ */ React.createElement(TagName, { key: `meta-${index}`, ...rest });
+    }
+    return /* @__PURE__ */ React.createElement("meta", { key: `meta-${index}`, ...tag });
+  }));
+};
+const isTitleTag = (tag) => {
+  return "title" in tag;
+};
+const otherTag = (tag) => {
+  return "tagType" in tag;
+};
+export {
+  Css,
+  Meta
+};

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":""}

package/dist/config.js

@@ -0,0 +1,5 @@
+globalThis.RWJS_API_GRAPHQL_URL = RWJS_ENV.RWJS_API_GRAPHQL_URL;
+globalThis.RWJS_API_URL = RWJS_ENV.RWJS_API_URL;
+globalThis.__REDWOOD__APP_TITLE = RWJS_ENV.__REDWOOD__APP_TITLE;
+globalThis.RWJS_EXP_STREAMING_SSR = RWJS_ENV.RWJS_EXP_STREAMING_SSR;
+globalThis.RWJS_EXP_RSC = RWJS_ENV.RWJS_EXP_RSC;

package/dist/entry/index.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/entry/index.js

@@ -0,0 +1,16 @@
+import React from "react";
+import { hydrateRoot, createRoot } from "react-dom/client";
+import App from "~redwood-app-root";
+import Routes from "~redwood-app-routes";
+const redwoodAppElement = document.getElementById("redwood-app");
+if (redwoodAppElement.children?.length > 0) {
+  hydrateRoot(
+    redwoodAppElement,
+    /* @__PURE__ */ React.createElement(App, null, /* @__PURE__ */ React.createElement(Routes, null))
+  );
+} else {
+  const root = createRoot(redwoodAppElement);
+  root.render(
+    /* @__PURE__ */ React.createElement(App, null, /* @__PURE__ */ React.createElement(Routes, null))
+  );
+}

package/dist/global.web-auto-imports.d.ts

@@ -0,0 +1,30 @@
+import type _React from 'react';
+import type { DocumentNode } from 'graphql';
+declare global {
+    const gql: (source: string | TemplateStringsArray | readonly string[], ...args: any[]) => DocumentNode;
+    type React = typeof _React;
+    interface Window {
+        /** URL or absolute path to the GraphQL serverless function */
+        RWJS_API_GRAPHQL_URL: string;
+        /** URL or absolute path to serverless functions */
+        RWJS_API_URL: string;
+        __REDWOOD__APP_TITLE: string;
+    }
+    type GraphQLOperationVariables = Record<string, any>;
+    interface QueryOperationResult<TData = any, TVariables = GraphQLOperationVariables> {
+        data: TData | undefined;
+        loading: boolean;
+    }
+    interface MutationOperationResult<TData, TVariables> {
+    }
+    interface GraphQLQueryHookOptions<TData, TVariables> {
+        variables?: TVariables;
+        [key: string]: any;
+    }
+    export interface GraphQLMutationHookOptions<TData, TVariables> {
+        variables?: TVariables;
+        onCompleted?: (data: TData) => void;
+        [key: string]: any;
+    }
+}
+//# sourceMappingURL=global.web-auto-imports.d.ts.map

package/dist/global.web-auto-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.web-auto-imports.d.ts","sourceRoot":"","sources":["../src/global.web-auto-imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,OAAO,CAAA;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAK3C,OAAO,CAAC,MAAM,CAAC;IAMb,MAAM,GAAG,EAAE,CACT,MAAM,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,MAAM,EAAE,EACzD,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,YAAY,CAAA;IAIjB,KAAK,KAAK,GAAG,OAAO,MAAM,CAAA;IAE1B,UAAU,MAAM;QACd,8DAA8D;QAC9D,oBAAoB,EAAE,MAAM,CAAA;QAC5B,mDAAmD;QACnD,YAAY,EAAE,MAAM,CAAA;QACpB,oBAAoB,EAAE,MAAM,CAAA;KAC7B;IAED,KAAK,yBAAyB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAIpD,UAAU,oBAAoB,CAC5B,KAAK,GAAG,GAAG,EACX,UAAU,GAAG,yBAAyB;QAEtC,IAAI,EAAE,KAAK,GAAG,SAAS,CAAA;QACvB,OAAO,EAAE,OAAO,CAAA;KAGjB;IAID,UAAU,uBAAuB,CAAC,KAAK,EAAE,UAAU;KAAI;IAGvD,UAAU,uBAAuB,CAAC,KAAK,EAAE,UAAU;QACjD,SAAS,CAAC,EAAE,UAAU,CAAA;QACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACnB;IAED,MAAM,WAAW,0BAA0B,CAAC,KAAK,EAAE,UAAU;QAC3D,SAAS,CAAC,EAAE,UAAU,CAAA;QACtB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,CAAA;QACnC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACnB;CACF"}

package/dist/graphql.d.ts

@@ -0,0 +1,24 @@
+import { type DocumentNode } from 'graphql';
+/**
+ * Given a query like the one below this function will return
+ * `FindBlogPostQuery`
+ *
+ * ```
+ *   export const QUERY = gql`
+ *     query FindBlogPostQuery($id: Int!) {
+ *       blogPost: post(id: $id) {
+ *         id
+ *         title
+ *         body
+ *         createdAt
+ *       }
+ *     }
+ *   `
+ * ```
+ *
+ * @param {DocumentNode} document
+ *   graphql query or mutation to get the operation name for
+ * @returns {string} empty string if no operation name could be found
+ */
+export declare function getOperationName(document: DocumentNode): string;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../src/graphql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,YAAY,EAAE,MAAM,SAAS,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,UAWtD"}

package/dist/graphql.js

@@ -0,0 +1,12 @@
+import { Kind } from "graphql";
+function getOperationName(document) {
+  for (const definition of document.definitions) {
+    if (definition.kind === Kind.OPERATION_DEFINITION && definition.name?.value) {
+      return definition.name.value;
+    }
+  }
+  return "";
+}
+export {
+  getOperationName
+};

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import './global.web-auto-imports.js';
+import './config.js';
+export { FatalErrorBoundary } from './components/FatalErrorBoundary.js';
+export { FetchConfigProvider, useFetchConfig, } from './components/FetchConfigProvider.js';
+export { GraphQLHooksProvider, useQuery, useMutation, useSubscription, } from './components/GraphQLHooksProvider.js';
+export * from './components/cell/CellCacheContext.js';
+export { createCell } from './components/cell/createCell.js';
+export type { CellProps, CellFailureProps, CellLoadingProps, CellSuccessProps, CellSuccessData, } from './components/cell/cellTypes.js';
+export * from './graphql.js';
+export * from './components/RedwoodProvider.js';
+export * from './components/MetaTags.js';
+export * from './components/Metadata.js';
+import * as helmetPkg from 'react-helmet-async';
+declare const Helmet: typeof helmetPkg.Helmet;
+export { Helmet as Head, Helmet };
+export * from './components/htmlTags.js';
+export * from './routeHooks.types.js';
+export * from './components/ServerInject.js';
+export type { TypedDocumentNode } from './components/GraphQLHooksProvider.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,8BAA8B,CAAA;AACrC,OAAO,aAAa,CAAA;AAEpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAA;AAEvE,OAAO,EACL,mBAAmB,EACnB,cAAc,GACf,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EACL,oBAAoB,EACpB,QAAQ,EACR,WAAW,EACX,eAAe,GAChB,MAAM,sCAAsC,CAAA;AAE7C,cAAc,uCAAuC,CAAA;AAErD,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAE5D,YAAY,EACV,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,GAChB,MAAM,gCAAgC,CAAA;AAEvC,cAAc,cAAc,CAAA;AAE5B,cAAc,iCAAiC,CAAA;AAE/C,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAA;AAE/C,QAAA,MAAQ,MAAM,yBAAc,CAAA;AAC5B,OAAO,EAAE,MAAM,IAAI,IAAI,EAAE,MAAM,EAAE,CAAA;AAEjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AAErC,cAAc,8BAA8B,CAAA;AAE5C,YAAY,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAA"}

package/dist/index.js

@@ -0,0 +1,36 @@
+import "./global.web-auto-imports.js";
+import "./config.js";
+import { FatalErrorBoundary } from "./components/FatalErrorBoundary.js";
+import {
+  FetchConfigProvider,
+  useFetchConfig
+} from "./components/FetchConfigProvider.js";
+import {
+  GraphQLHooksProvider,
+  useQuery,
+  useMutation,
+  useSubscription
+} from "./components/GraphQLHooksProvider.js";
+export * from "./components/cell/CellCacheContext.js";
+import { createCell } from "./components/cell/createCell.js";
+export * from "./graphql.js";
+export * from "./components/RedwoodProvider.js";
+export * from "./components/MetaTags.js";
+export * from "./components/Metadata.js";
+import * as helmetPkg from "react-helmet-async";
+const { Helmet } = helmetPkg;
+export * from "./components/htmlTags.js";
+export * from "./routeHooks.types.js";
+export * from "./components/ServerInject.js";
+export {
+  FatalErrorBoundary,
+  FetchConfigProvider,
+  GraphQLHooksProvider,
+  Helmet as Head,
+  Helmet,
+  createCell,
+  useFetchConfig,
+  useMutation,
+  useQuery,
+  useSubscription
+};

package/dist/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/routeHooks.types.d.ts

@@ -0,0 +1,12 @@
+import type { TagDescriptor } from './components/htmlTags.js';
+export type RouteHookOutput = {
+    meta: TagDescriptor[];
+};
+export interface RouteHookEvent {
+    params: Record<string, string>;
+    headers: Headers;
+    query: Record<string, string | string[] | undefined>;
+    appRouteHook?: RouteHookOutput;
+}
+export type MetaHook = (event: RouteHookEvent) => Promise<TagDescriptor[] | TagDescriptor> | TagDescriptor[] | TagDescriptor;
+//# sourceMappingURL=routeHooks.types.d.ts.map

package/dist/routeHooks.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routeHooks.types.d.ts","sourceRoot":"","sources":["../src/routeHooks.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAE7D,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,aAAa,EAAE,CAAA;CACtB,CAAA;AACD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAA;IAGpD,YAAY,CAAC,EAAE,eAAe,CAAA;CAC/B;AAED,MAAM,MAAM,QAAQ,GAAG,CACrB,KAAK,EAAE,cAAc,KAClB,OAAO,CAAC,aAAa,EAAE,GAAG,aAAa,CAAC,GAAG,aAAa,EAAE,GAAG,aAAa,CAAA"}