eddev 2.0.0-beta.38 → 2.0.0-beta.39

package/dist/app/entry/ssr-root-client.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from "react";
+import { RouteMetaTag } from "../lib/routing/types.js";
+export declare function SSRClientRoot(props: {
+    assets: ReactNode;
+    metaTags: RouteMetaTag[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/app/entry/ssr-root.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+import type { RouteData, RouteMetaTag } from "../lib/routing/types.js";
+import type { RouteLoader } from "../lib/routing/loader.js";
+export declare function SSRRoot(props: {
+    pathname: string;
+    initialData: RouteData;
+    assets: ReactNode;
+    loader: RouteLoader;
+    metaTags: RouteMetaTag[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/app/entry/ssr-root.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { getQueryClient } from "../utils/query-client.js";
+import { SSRRouter } from "../lib/routing/components/SSRRouter.js";
+import { getRouteMeta, normalizeRoute } from "../lib/routing/utils.js";
+import { MetaTags } from "./MetaTags.js";
+export function SSRRoot(props) {
+    const loader = props.loader;
+    loader.setAppData(props.initialData.appData.data);
+    loader.populateRouteData(props.pathname, props.initialData);
+    return (_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx("link", { rel: "icon", href: "/favicon.ico" }), _jsx(MetaTags, { tags: props.metaTags }), props.assets] }), _jsx("body", { children: _jsx(QueryClientProvider, { client: getQueryClient(), children: _jsx(Suspense, { children: _jsx(SSRRouter, { loader: loader, route: normalizeRoute({
+                                id: "initial",
+                                component: loader.getRouteComponent(props.initialData.view),
+                                key: "",
+                                props: props.initialData.viewData.data,
+                                view: props.initialData.view,
+                                search: "",
+                                pathname: props.pathname,
+                                query: {},
+                                hash: "",
+                                meta: getRouteMeta(props.initialData),
+                            }) }) }) }) })] }));
+}

package/dist/app/lib/blocks/EditableText.d.ts

@@ -0,0 +1,41 @@
+import { ElementType } from "react";
+import { InlineValueStore } from "./inline-editing.js";
+export type InlineTextValueStore = InlineValueStore<string>;
+type Props<T extends ElementType> = {
+    /** Specify a tag name or React component */
+    as?: T;
+    /** Prevents this text element from being multi-line */
+    disableLineBreaks?: boolean;
+    /** Enables the rich text toolbar */
+    inlineToolbar?: boolean;
+    /** Specify default content to use on the frontend if nothing has been entered */
+    defaultValue?: string;
+    /**
+     * Append a new block when the user hits 'Enter' while editing this text.
+     * Specify 'true' to append a new paragraph block, or a string to specify a different block type.
+     **/
+    appendOnEnter?: boolean | string;
+    /** An optional placeholder to indicate a typable area */
+    placeholder?: string;
+} & {
+    /**
+     * The 'key' of this editable text value.
+     *
+     * @deprecated use the `store` prop instead
+     **/
+    id?: string;
+    /**
+     *
+     * Instead of an `id`, you can provide a tuple of `[value, setValue]` to store the value elsewhere.
+     *
+     * This can be combined with `useInlineEditableValue()`, `usePostTitleEditor()` or even `useState()`
+     **/
+    store: InlineTextValueStore | string;
+} & Omit<React.ComponentPropsWithoutRef<T>, "id"> & MaybeAsProp<React.ComponentPropsWithoutRef<T>>;
+type MaybeAsProp<T> = T extends {
+    as?: infer U;
+} ? (U extends unknown ? {} : {
+    asProp?: U;
+}) : {};
+export declare function EditableText<T extends ElementType>({ id, as, appendOnEnter, store, ...props }: Props<T>): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/app/lib/blocks/EditableText.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRouter } from "../routing/hooks/useRouter.js";
+import { useBlockAppender, useBlockContext, useValueStore } from "./inline-editing.js";
+export function EditableText({ id, as, appendOnEnter, store, ...props }) {
+    if (env.admin) {
+        const readOnly = useBlockContext()?.readonly;
+        if (!readOnly) {
+            const [value, setValue] = useValueStore(store ?? id);
+            const appendBlocks = useBlockAppender();
+            return (_jsx(wp.blockEditor.RichText, { ...props, tagName: as, value: value || "", onChange: setValue, inlineToolbar: props.inlineToolbar, disableLineBreaks: props.disableLineBreaks, onKeyDownCapture: (e) => {
+                    if (e.key === "Enter" && appendOnEnter && appendBlocks) {
+                        appendBlocks([
+                            wp.blocks.createBlock(typeof appendOnEnter === "string" ? appendOnEnter : "core/paragraph"),
+                        ]);
+                        e.preventDefault();
+                        e.stopPropagation();
+                    }
+                } }));
+        }
+    }
+    let [value] = useValueStore(store ?? id);
+    const handleClickEvent = useRouter((r) => r.handleClickEvent);
+    const otherProps = { ...props };
+    delete otherProps.inlineToolbar;
+    delete otherProps.disableLineBreaks;
+    delete otherProps.id;
+    otherProps.as = otherProps.asProp ?? undefined;
+    delete otherProps.asProp;
+    delete otherProps.placeholder;
+    if (value === "" || typeof value !== "string") {
+        if (props.defaultValue) {
+            value = props.defaultValue;
+        }
+        else {
+            return null;
+        }
+    }
+    const Element = as || "div";
+    return (_jsx(Element, { dangerouslySetInnerHTML: { __html: value }, 
+        /**
+         * Allow the router to handle link clicks, passing all clicks to the router.
+         * We allow onClick on the current element to occur first, so that preventDefault can be called.
+         * The router will filter out clicks where appropriate.
+         */
+        onClick: (e) => {
+            if (props.onClick)
+                props.onClick(e);
+            handleClickEvent?.(e);
+        }, ...otherProps }));
+}

package/dist/app/lib/blocks/InnerBlocks.d.ts

@@ -0,0 +1,52 @@
+import { FunctionComponent } from "react";
+import { ContentBlockLayoutProps } from "./ContentBlocks.js";
+import { BlockTemplate } from "./editor/block-templates.js";
+type AppenderConfig = {
+    type: "default" | "button" | CustomBlockAppender;
+    className?: string;
+};
+export type CustomBlockAppender = FunctionComponent<{
+    onToggle: () => void;
+    disabled: boolean;
+    isOpen: boolean;
+    blockTitle: string;
+    hasSingleBlockType: boolean;
+}>;
+export declare function createAppender(comp: CustomBlockAppender): {
+    type: CustomBlockAppender;
+};
+type InnerBlocksProps = {
+    /** A list of allowed blocks, and/or block tags. */
+    allowedBlocks?: (ChildBlockTypeName | BlockTagName)[];
+    /** Specify the block list as either horizontal or vertical */
+    orientation?: "horizontal" | "vertical";
+    /**
+     * An optional extra className to apply to the wrapper div, in the Gutenberg editor.
+     *
+     * NOTE: This will have no effect on the frontend, since no wrapper div is created on the frontend.
+     **/
+    adminClassName?: string;
+    /**
+     *
+     */
+    template?: BlockTemplate;
+    /**
+     * `false` allows all operations
+     * `"all"` prevents all operations. It is not possible to insert new blocks, move existing blocks, or delete blocks
+     * `"insert"` prevents inserting or removing blocks, but allows moving existing blocks
+     * `"contentOnly"` — prevents all operations, but allows rich text editing. Additionally, the block types that don’t have content are hidden from the list view and can’t gain focus within the block list. Unlike the other lock types, this is not overridable by children.
+     *
+     * @see https://developer.wordpress.org/block-editor/reference-guides/block-api/block-templates/#locking
+     *
+     * @default false
+     *
+     */
+    templateLock?: "all" | "insert" | "contentOnly" | false;
+    appender?: AppenderConfig;
+    prioritizedInserterBlocks?: ChildBlockTypeName[];
+} & ContentBlockLayoutProps;
+/**
+ * Allows child blocks to be added to the current block context.
+ */
+export declare function InnerBlocks(props: InnerBlocksProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/app/lib/blocks/InnerBlocks.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ContentBlocks } from "./ContentBlocks.js";
+import { transformBlockTemplate } from "./editor/block-templates.js";
+import { blocksByTag } from "./editor/blocks-by-tag.js";
+import { useBlockContext, useInnerBlocks } from "./inline-editing.js";
+const Appender = (props) => {
+    const clientId = useBlockContext()?.block[1].clientId;
+    if (props.type === "button") {
+        return _jsx(wp.blockEditor.ButtonBlockAppender, { className: props.className, rootClientId: clientId });
+    }
+    else if (typeof props.type === "function") {
+        const Type = props.type;
+        return (_jsx(wp.blockEditor.Inserter, { renderToggle: (p) => {
+                return _jsx(Type, { ...p });
+            }, rootClientId: clientId }));
+    }
+    else {
+        return (_jsx(wp.blockEditor.DefaultBlockAppender
+        // @ts-ignore
+        , { 
+            // @ts-ignore
+            className: props.className, rootClientId: clientId, lastBlockClientId: clientId }));
+    }
+};
+export function createAppender(comp) {
+    return {
+        type: comp,
+    };
+}
+/**
+ * Allows child blocks to be added to the current block context.
+ */
+export function InnerBlocks(props) {
+    if (env.admin) {
+        const inlineContext = useBlockContext();
+        if (!inlineContext?.readonly) {
+            const innerBlocksProps = wp.blockEditor.useInnerBlocksProps({}, {
+                orientation: props.orientation ?? "vertical",
+                allowedBlocks: props.allowedBlocks ? blocksByTag.expand(props.allowedBlocks) : undefined,
+                prioritizedInserterBlocks: props.prioritizedInserterBlocks,
+                renderAppender: props.appender
+                    ? () => _jsx(Appender, { ...props.appender })
+                    : wp.blockEditor.InnerBlocks.ButtonBlockAppender,
+                templateLock: props.templateLock ?? false,
+                template: props.template ? transformBlockTemplate(props.template) : undefined,
+            });
+            return (_jsx("div", { ...innerBlocksProps, className: [innerBlocksProps.className, props.adminClassName].filter(Boolean).join(" ") }));
+            // return (
+            //   <wp.blockEditor.InnerBlocks
+            //     // @ts-ignore
+            //     orientation={props.orientation}
+            //     prioritizedInserterBlocks={props.prioritizedInserterBlocks}
+            //     allowedBlocks={props.allowedBlocks ? blocksByTag.expand(props.allowedBlocks) : undefined}
+            //     renderAppender={props.appender ? () => <Appender {...props.appender!} /> : undefined}
+            //     templateLock={(props.templateLock as any) ?? false}
+            //     template={props.template ? transformBlockTemplate(props.template) : undefined}
+            //   />
+            // )
+        }
+    }
+    const blocks = useInnerBlocks();
+    return _jsx(ContentBlocks, { blocks: blocks, spacer: props.spacer, wrapBlock: props.wrapBlock });
+}

package/dist/app/lib/blocks/defineBlock.d.ts

@@ -0,0 +1,2 @@
+import { ComponentType, ReactNode } from "react";
+export declare function defineBlock<TName extends keyof BlockProps>(name: TName, component: (props: BlockProps[TName]) => ReactNode): ComponentType<BlockProps[TName]>;

package/dist/app/lib/blocks/defineBlock.js

@@ -0,0 +1,3 @@
+export function defineBlock(name, component) {
+    return component;
+}

package/dist/app/lib/blocks/editor/controls.d.ts

@@ -0,0 +1,10 @@
+import { PropsWithChildren } from "react";
+/**
+ * Allows you to render arbitrary sidebar content when this block is selected.
+ *
+ * You can use this in cases where ACF is overkill.
+ *
+ * @see https://developer.wordpress.org/block-editor/getting-started/fundamentals/block-in-the-editor/#settings-sidebar
+ */
+export declare function InspectorControls(props: PropsWithChildren<{}>): import("react/jsx-runtime").JSX.Element | null;
+export declare function BlockControls(props: PropsWithChildren<{}>): import("react/jsx-runtime").JSX.Element | null;

package/dist/app/lib/blocks/editor/controls.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Allows you to render arbitrary sidebar content when this block is selected.
+ *
+ * You can use this in cases where ACF is overkill.
+ *
+ * @see https://developer.wordpress.org/block-editor/getting-started/fundamentals/block-in-the-editor/#settings-sidebar
+ */
+export function InspectorControls(props) {
+    if (env.admin) {
+        return _jsx(wp.blockEditor.InspectorControls, { children: props.children });
+    }
+    return null;
+}
+export function BlockControls(props) {
+    if (env.admin) {
+        return _jsx(wp.blockEditor.BlockControls, { controls: undefined, children: props.children });
+    }
+    return null;
+}

package/dist/app/lib/blocks/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./ContentBlocks.js";
+export * from "./EditableText.js";
+export * from "./InnerBlocks.js";
+export * from "./defineBlock.js";
+export * from "./editor/controls.js";
+export * from "./editor/usePostEditor.js";
+export * from "./block-utils.js";
+export { defineEditorConfig } from "./editor/editor-config.js";
+export { useBlockContext, useInlineEditableValue, useInnerBlocks, useTemplate } from "./inline-editing.js";

package/dist/app/lib/blocks/index.js

@@ -0,0 +1,9 @@
+export * from "./ContentBlocks.js";
+export * from "./EditableText.js";
+export * from "./InnerBlocks.js";
+export * from "./defineBlock.js";
+export * from "./editor/controls.js";
+export * from "./editor/usePostEditor.js";
+export * from "./block-utils.js";
+export { defineEditorConfig } from "./editor/editor-config.js";
+export { useBlockContext, useInlineEditableValue, useInnerBlocks, useTemplate } from "./inline-editing.js";

package/dist/app/lib/devtools/index.d.ts

@@ -0,0 +1 @@
+export * from "./dev-tools-store.js";

package/dist/app/lib/devtools/index.js

@@ -0,0 +1 @@
+export * from "./dev-tools-store.js";

package/dist/app/lib/devtools/tailwind.config.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    darkMode: [];
+    important: string;
+    content: string[];
+    theme: {
+        fontFamily: {
+            mono: [string, string, string];
+            body: [string, string, string];
+        };
+        fontSize: {
+            ui: [string, string];
+        };
+        extend: {
+            height: {
+                button: string;
+            };
+        };
+    };
+    corePlugins: {
+        preflight: false;
+    };
+};
+export default _default;

package/dist/app/lib/devtools/tailwind.config.js

@@ -0,0 +1,24 @@
+// @ts-ignore
+export default {
+    darkMode: [],
+    important: ".eddev-ui",
+    // @ts-ignore
+    content: [__dirname + "/**/*.{js,jsx,ts,tsx}"],
+    theme: {
+        fontFamily: {
+            mono: ["Roboto Mono", "menlo", "monospace"],
+            body: ["Inter", "Roboto", "sans-serif"],
+        },
+        fontSize: {
+            ui: ["12px", "16px"],
+        },
+        extend: {
+            height: {
+                button: "22px",
+            },
+        },
+    },
+    corePlugins: {
+        preflight: false,
+    },
+};

package/dist/app/lib/devtools/useQueryDebug.d.ts

@@ -0,0 +1,15 @@
+export type QueryDebugItem = {
+    file: string;
+    errors: string[];
+    duration: number;
+    label: string;
+    children: QueryDebugItem[];
+};
+export declare function setQueryDebug(value: QueryDebugItem | undefined): void;
+export declare function useQueryDebugData(): {
+    readonly file: string;
+    readonly errors: readonly string[];
+    readonly duration: number;
+    readonly label: string;
+    readonly children: readonly any[];
+} | undefined;

package/dist/app/lib/devtools/useQueryDebug.js

@@ -0,0 +1,10 @@
+import { proxy, useSnapshot } from "valtio";
+const store = proxy({
+    value: undefined,
+});
+export function setQueryDebug(value) {
+    store.value = value;
+}
+export function useQueryDebugData() {
+    return useSnapshot(store).value;
+}

package/dist/app/lib/dynamic/index.d.ts

@@ -0,0 +1 @@
+export { dynamic, DynamicComponent } from "./dynamic.js";

package/dist/app/lib/dynamic/index.js

@@ -0,0 +1 @@
+export { dynamic } from "./dynamic.js";

package/dist/app/lib/hooks/apiConfig.d.ts

@@ -0,0 +1,20 @@
+export type APIConfigStore = {
+    /**
+     * Any value, which will be used as part of the cache key for each query.
+     *
+     * Changing this value at runtime will invalidate any cached queries, and re-execute them if needed.
+     **/
+    customQueryKey?: any;
+    /**
+     * Allows you to override the fetch options used when calling a query or mutation.
+     * This can be used for adding things like Authorization headers to every (or certain) requests.
+     */
+    customQueryFetchOptions?: (type: "query" | "mutation", queryName: string, queryArgs: any, url: string, opts: RequestInit) => RequestInit | Promise<RequestInit>;
+    /**
+     * Update aspects of the API client
+     */
+    onResponse?: (response: Response) => void;
+    set: (config: Partial<APIConfigStore>) => void;
+};
+export declare const apiConfig: APIConfigStore;
+export declare function useAPIConfig(): APIConfigStore;

package/dist/app/lib/hooks/apiConfig.js

@@ -0,0 +1,9 @@
+import { proxy } from "valtio";
+export const apiConfig = proxy({
+    set: (config) => {
+        Object.assign(apiConfig, config);
+    },
+});
+export function useAPIConfig() {
+    return apiConfig;
+}

package/dist/app/lib/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./useAppData.js";
+export * from "./useRPC.js";
+export * from "./queryUtils.js";
+export * from "./apiConfig.js";

package/dist/app/lib/hooks/index.js

@@ -0,0 +1,4 @@
+export * from "./useAppData.js";
+export * from "./useRPC.js";
+export * from "./queryUtils.js";
+export * from "./apiConfig.js";

package/dist/app/lib/hooks/queryUtils.d.ts

@@ -0,0 +1,49 @@
+import { FetchQueryOptions, UndefinedInitialDataInfiniteOptions, UndefinedInitialDataOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryResult } from "@tanstack/react-query";
+type OptionalMaybes<T> = T extends any[] ? T : T extends {
+    [key: string]: any;
+} ? {
+    [K in keyof T]: T[K] extends null ? T[K] | undefined : T[K];
+} : T;
+type MaybeVars = {
+    [key: string]: any;
+} | undefined;
+export type QueryError = Error & {
+    messages: string[];
+    statusCode: number;
+};
+/** Regular queries */
+type CreateUseQueryOptions = {
+    name: string;
+};
+export type UseQueryFunction<TData, TVars> = ((args: OptionalMaybes<TVars>, options?: Omit<UndefinedInitialDataOptions<TData, QueryError, TData>, "queryKey" | "queryFn"> & {
+    headers?: Record<string, string>;
+}) => UseQueryResult<TData, QueryError>) & {
+    fetch: (args: OptionalMaybes<TVars>, options?: Omit<FetchQueryOptions<TData, QueryError, TData>, "queryKey" | "queryFn"> & {
+        headers?: Record<string, string>;
+    }) => Promise<TData>;
+};
+export declare function createUseQuery<TData extends any, TVars extends MaybeVars>(init: CreateUseQueryOptions): UseQueryFunction<TData, TVars>;
+/** Regular queries */
+type CreateUseInfiniteQueryOptions = {
+    name: string;
+    defaultLimit: number;
+    paths: Record<"nodesPath" | "pageInfoPath" | "endCursorPath" | "hasNextPagePath", string[]>;
+};
+export type UseInfiniteQueryFunction<TData, TVars> = (args: OptionalMaybes<Omit<TVars, "cursor">>, options?: Omit<UndefinedInitialDataInfiniteOptions<TData, QueryError, TData, any[]>, "queryKey" | "queryFn" | "initialData" | "initialPageParam" | "getNextPageParam" | "select"> & {
+    headers?: Record<string, string>;
+    /** Initial data can be passed in, but should match the original GraphQL query in structure (including nodes/hasNextPage/endCursor) */
+    initialData?: any;
+}) => UseInfiniteQueryResult<{
+    nodes: TData;
+    total?: number | null;
+}, QueryError>;
+export declare function createUseInfiniteQuery<TData extends any, TVars extends MaybeVars>(init: CreateUseInfiniteQueryOptions): UseInfiniteQueryFunction<TData, TVars>;
+export type UseMutationFunction<TData, TArgs> = ((options?: Omit<UseMutationOptions<TData, QueryError, TArgs>, "mutationFn"> & {
+    headers?: Record<string, string>;
+}) => UseMutationResult<TData, QueryError, TArgs>) & {
+    mutate: (args: OptionalMaybes<TArgs>, options?: Omit<FetchQueryOptions<TData, QueryError, TData>, "queryKey" | "queryFn"> & {
+        headers?: Record<string, string>;
+    }) => Promise<TData>;
+};
+export declare function createUseMutation<TData extends any, TArgs extends MaybeVars>(init: CreateUseQueryOptions): UseMutationFunction<TData, TArgs>;
+export {};