@parhelia/alpaca 0.1.12451

package/dist/GraphQL.d.ts

@@ -0,0 +1,2 @@
+export declare function GraphQL(): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=GraphQL.d.ts.map

package/dist/GraphQL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphQL.d.ts","sourceRoot":"","sources":["../src/GraphQL.tsx"],"names":[],"mappings":"AA+BA,wBAAgB,OAAO,mDAmQtB"}

package/dist/GraphQL.js

@@ -0,0 +1,185 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { ActionButton, createAgentCommand, getComponentById, SecretAgentIcon, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, useEditContext, } from "@parhelia/core";
+import { getGraphQLSchema, } from "./graphqlService";
+import { GraphiQLPanel } from "./GraphiQLPanel";
+function sameItem(left, right) {
+    return (!!left &&
+        !!right &&
+        left.id === right.id &&
+        left.language === right.language &&
+        left.version === right.version);
+}
+export function GraphQL() {
+    const editContext = useEditContext();
+    const pageItem = editContext?.page?.item ?? editContext?.item;
+    const selectionKey = editContext?.selection?.join("|") || "";
+    const [query, setQuery] = useState("");
+    const [schemaResult, setSchemaResult] = useState({});
+    const [showSchemaSpinner, setShowSchemaSpinner] = useState(false);
+    const [aiGeneratedQuery, setAiGeneratedQuery] = useState("");
+    const [graphiqlVariables, setGraphiqlVariables] = useState("{}");
+    const [baseItem, setBaseItem] = useState(null);
+    const selectedComponent = useMemo(() => {
+        if (!editContext?.page || (editContext.selection?.length || 0) !== 1) {
+            return null;
+        }
+        return getComponentById(editContext.selection[0], editContext.page) || null;
+    }, [editContext?.page, selectionKey]);
+    const baseItemDescriptor = useMemo(() => {
+        const componentItem = selectedComponent?.datasourceItem || selectedComponent?.items?.[0];
+        return componentItem || pageItem?.descriptor || pageItem || null;
+    }, [selectedComponent, pageItem]);
+    const currentItem = useMemo(() => baseItemDescriptor
+        ? {
+            id: baseItemDescriptor.id,
+            language: baseItemDescriptor.language,
+            version: baseItemDescriptor.version,
+        }
+        : null, [
+        baseItemDescriptor?.id,
+        baseItemDescriptor?.language,
+        baseItemDescriptor?.version,
+    ]);
+    const baseItemLabel = useMemo(() => {
+        const componentItem = selectedComponent?.datasourceItem || selectedComponent?.items?.[0];
+        return componentItem?.name || pageItem?.name || currentItem?.id || "";
+    }, [selectedComponent, pageItem?.name, currentItem?.id]);
+    useEffect(() => {
+        let isCancelled = false;
+        const loadBaseItem = async () => {
+            if (!editContext || !baseItemDescriptor) {
+                setBaseItem(null);
+                return;
+            }
+            if (pageItem &&
+                sameItem({
+                    id: pageItem.id,
+                    language: pageItem.language,
+                    version: pageItem.version,
+                }, {
+                    id: baseItemDescriptor.id,
+                    language: baseItemDescriptor.language,
+                    version: baseItemDescriptor.version,
+                })) {
+                setBaseItem(pageItem);
+                return;
+            }
+            try {
+                const nextItem = await editContext.itemsRepository.getItem(baseItemDescriptor);
+                if (!isCancelled) {
+                    setBaseItem(nextItem || null);
+                }
+            }
+            catch (error) {
+                console.error("Failed to load base item for GraphQL panel:", error);
+                if (!isCancelled) {
+                    setBaseItem(null);
+                }
+            }
+        };
+        void loadBaseItem();
+        return () => {
+            isCancelled = true;
+        };
+    }, [
+        editContext,
+        baseItemDescriptor?.id,
+        baseItemDescriptor?.language,
+        baseItemDescriptor?.version,
+        pageItem,
+    ]);
+    const queryField = useMemo(() => baseItem?.fields?.find((field) => field.name === "_GraphQL" || field.name === "graphql_query") || null, [baseItem]);
+    useEffect(() => {
+        setQuery(queryField?.rawValue || "");
+    }, [queryField?.id, queryField?.rawValue]);
+    useEffect(() => {
+        setSchemaResult({});
+        setGraphiqlVariables("{}");
+        setAiGeneratedQuery("");
+    }, [currentItem?.id, currentItem?.language, currentItem?.version]);
+    useEffect(() => {
+        if (currentItem && !schemaResult?.data && !showSchemaSpinner) {
+            void fetchSchema();
+        }
+    }, [
+        currentItem?.id,
+        currentItem?.language,
+        currentItem?.version,
+        schemaResult?.data,
+        showSchemaSpinner,
+    ]);
+    useEffect(() => {
+        if (!editContext || !currentItem)
+            return;
+        const factoryName = "graphql:context:v1";
+        const factory = async () => ({
+            schema: schemaResult?.data || "",
+            currentQuery: query,
+            itemContext: {
+                id: currentItem.id,
+                language: currentItem.language,
+                version: currentItem.version,
+            },
+        });
+        editContext.registerContextFactory?.(factoryName, factory);
+        return () => editContext.unregisterContextFactory?.(factoryName);
+    }, [
+        editContext,
+        currentItem?.id,
+        currentItem?.language,
+        currentItem?.version,
+        query,
+        schemaResult?.data,
+    ]);
+    if (!currentItem)
+        return null;
+    const activeItem = currentItem;
+    async function fetchSchema() {
+        setShowSchemaSpinner(true);
+        try {
+            const response = await getGraphQLSchema({
+                id: activeItem.id,
+                language: activeItem.language,
+                version: activeItem.version,
+                mode: "edit",
+                siteName: "website",
+            });
+            setSchemaResult(response.error
+                ? {
+                    status: response.status,
+                    error: response.error,
+                    transport: response.transport,
+                }
+                : {
+                    data: response.data,
+                    status: response.status,
+                    transport: response.transport,
+                });
+        }
+        catch (error) {
+            console.error("Schema fetch error:", error);
+            setSchemaResult({ error: String(error) });
+        }
+        finally {
+            setShowSchemaSpinner(false);
+        }
+    }
+    const applyQueryToEditor = (newQuery) => {
+        setQuery(newQuery);
+        setAiGeneratedQuery(newQuery);
+    };
+    return (_jsxs("div", { className: "relative flex h-full min-h-0 flex-col overflow-hidden text-xs", children: [aiGeneratedQuery && aiGeneratedQuery !== query && (_jsxs("div", { className: "shrink-0 flex items-center gap-2 border-b border-yellow-200 bg-yellow-50 p-2 text-xs", children: [_jsx("span", { className: "text-yellow-800", children: "AI generated a new query" }), _jsx(ActionButton, { onClick: () => applyQueryToEditor(aiGeneratedQuery), className: "p-1 text-xs", variant: "outline", children: "Apply" }), _jsx(ActionButton, { onClick: () => setAiGeneratedQuery(""), className: "p-1", variant: "ghost", children: "x" })] })), _jsx(GraphiQLPanel, { item: currentItem, itemLabel: baseItemLabel, query: query, variables: graphiqlVariables, onQueryChange: setQuery, onVariablesChange: setGraphiqlVariables, onExecutionResult: () => { }, headerActions: _jsx(TooltipProvider, { delayDuration: 300, children: _jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs(ActionButton, { variant: "outline", className: "h-8 w-8 rounded-full p-0", onClick: () => {
+                                        editContext?.executeCommand?.({
+                                            command: createAgentCommand,
+                                            data: {
+                                                profileName: "GraphQL Assistant",
+                                                contextFactory: "graphql:context:v1",
+                                                initialPrompt: "Help with the current GraphQL query and schema.",
+                                                additionalData: {
+                                                    source: "GraphQLPanel",
+                                                },
+                                            },
+                                        });
+                                    }, children: [_jsx(SecretAgentIcon, { size: 16, strokeWidth: 1.5 }), _jsx("span", { className: "sr-only", children: "Start GraphQL Agent" })] }) }), _jsx(TooltipContent, { children: "Start GraphQL Agent" })] }) }) })] }));
+}

package/dist/GraphiQLPanel.d.ts

@@ -0,0 +1,15 @@
+import "graphiql/style.css";
+import "@graphiql/plugin-explorer/style.css";
+import "graphiql/setup-workers/webpack";
+import { GraphiQLExecutionResult, GraphQLPanelItem } from "./graphqlService";
+export declare function GraphiQLPanel({ item, query, variables, onQueryChange, onVariablesChange, onExecutionResult, itemLabel, headerActions, }: {
+    item: GraphQLPanelItem;
+    query: string;
+    variables: string;
+    onQueryChange: (query: string) => void;
+    onVariablesChange: (variables: string) => void;
+    onExecutionResult: (result: GraphiQLExecutionResult) => void;
+    itemLabel?: string;
+    headerActions?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=GraphiQLPanel.d.ts.map

package/dist/GraphiQLPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphiQLPanel.d.ts","sourceRoot":"","sources":["../src/GraphiQLPanel.tsx"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,CAAC;AAC5B,OAAO,qCAAqC,CAAC;AAC7C,OAAO,gCAAgC,CAAC;AAOxC,OAAO,EAGL,uBAAuB,EAEvB,gBAAgB,EAEjB,MAAM,kBAAkB,CAAC;AAwD1B,wBAAgB,aAAa,CAAC,EAC5B,IAAI,EACJ,KAAK,EACL,SAAS,EACT,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,SAAS,EACT,aAAa,GACd,EAAE;IACD,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,iBAAiB,EAAE,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CACjC,2CA4IA"}

package/dist/GraphiQLPanel.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import "graphiql/style.css";
+import "@graphiql/plugin-explorer/style.css";
+import "graphiql/setup-workers/webpack";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { GraphiQL as GraphiQLIDE } from "graphiql";
+import { useGraphiQL, useGraphiQLActions } from "@graphiql/react";
+import { explorerPlugin } from "@graphiql/plugin-explorer";
+import { executeGraphiQLRequest, fetchGraphiQLSchema, isSchemaIntrospectionQuery, } from "./graphqlService";
+function GraphiQLSyncBridge({ query, variables, }) {
+    const { updateActiveTabValues } = useGraphiQLActions();
+    const activeQuery = useGraphiQL((state) => state.tabs[state.activeTabIndex]?.query ?? "");
+    const activeVariables = useGraphiQL((state) => state.tabs[state.activeTabIndex]?.variables ?? "");
+    const pendingExternalState = useRef(null);
+    useEffect(() => {
+        if (activeQuery !== query || activeVariables !== variables) {
+            pendingExternalState.current = { query, variables };
+            updateActiveTabValues({ query, variables });
+        }
+    }, [activeQuery, activeVariables, query, updateActiveTabValues, variables]);
+    useEffect(() => {
+        if (pendingExternalState.current &&
+            pendingExternalState.current.query === activeQuery &&
+            pendingExternalState.current.variables === activeVariables) {
+            pendingExternalState.current = null;
+        }
+    }, [activeQuery, activeVariables]);
+    return null;
+}
+function parseVariables(variables) {
+    if (!variables.trim()) {
+        return null;
+    }
+    try {
+        return JSON.parse(variables);
+    }
+    catch (error) {
+        throw new Error(error instanceof Error
+            ? `Variables JSON is invalid: ${error.message}`
+            : "Variables JSON is invalid.");
+    }
+}
+export function GraphiQLPanel({ item, query, variables, onQueryChange, onVariablesChange, onExecutionResult, itemLabel, headerActions, }) {
+    const [schemaResult, setSchemaResult] = useState({});
+    const [isRefreshingSchema, setIsRefreshingSchema] = useState(false);
+    const explorer = useMemo(() => explorerPlugin(), []);
+    const plugins = useMemo(() => [explorer], [explorer]);
+    const handleEditHeaders = useCallback(() => { }, []);
+    const graphiqlSchema = schemaResult.schema ?? null;
+    const refreshSchema = useCallback(async () => {
+        setIsRefreshingSchema(true);
+        try {
+            const result = await fetchGraphiQLSchema(item);
+            setSchemaResult(result);
+        }
+        finally {
+            setIsRefreshingSchema(false);
+        }
+    }, [item.id, item.language, item.version]);
+    useEffect(() => {
+        setSchemaResult({});
+    }, [item.id, item.language, item.version]);
+    useEffect(() => {
+        if (!graphiqlSchema && !isRefreshingSchema) {
+            void refreshSchema();
+        }
+    }, [graphiqlSchema, isRefreshingSchema, refreshSchema]);
+    const fetcher = useCallback(async (graphQLParams) => {
+        if (!graphQLParams.query) {
+            return {
+                errors: [{ message: "No GraphQL query was provided." }],
+            };
+        }
+        let parsedVariables = null;
+        try {
+            parsedVariables = parseVariables(variables);
+        }
+        catch (error) {
+            return {
+                errors: [
+                    { message: error instanceof Error ? error.message : String(error) },
+                ],
+            };
+        }
+        const result = await executeGraphiQLRequest({
+            item,
+            query: graphQLParams.query,
+            variables: graphQLParams.variables ?? parsedVariables,
+            operationName: graphQLParams.operationName,
+        });
+        if (isSchemaIntrospectionQuery(graphQLParams.query)) {
+            setSchemaResult(result);
+        }
+        else {
+            onExecutionResult(result);
+        }
+        if (result.error) {
+            return {
+                data: result.data,
+                errors: [{ message: result.error }],
+            };
+        }
+        return {
+            data: result.data ?? null,
+            errors: result.errors,
+        };
+    }, [item.id, item.language, item.version, onExecutionResult, variables]);
+    const lastTransportMessage = useMemo(() => {
+        if (schemaResult.transport?.used === "v1-fallback") {
+            return `Schema fetch fell back to v1 after v2 status ${schemaResult.transport.fallbackFromStatus}.`;
+        }
+        return "";
+    }, [schemaResult.transport]);
+    return (_jsxs("div", { className: "flex min-h-0 flex-1 flex-col bg-white", children: [_jsx("style", { children: `
+        .alpaca-graphiql-shell .graphiql-logo {
+          display: none;
+        }
+      ` }), _jsxs("div", { className: "flex items-center justify-between gap-3 border-b border-gray-200 bg-gray-50 px-3 py-2 text-xs text-gray-600", children: [_jsxs("div", { className: "flex min-w-0 flex-wrap items-center gap-2", children: [_jsxs("span", { children: ["Base item: ", _jsx("span", { className: "font-mono", children: itemLabel || item.id })] }), _jsxs("span", { children: [item.language, " v", item.version] })] }), headerActions && (_jsx("div", { className: "ml-auto flex shrink-0 items-center gap-2", children: headerActions }))] }), !!lastTransportMessage && (_jsx("div", { className: "border-b border-amber-300 bg-amber-50 px-3 py-2 text-xs text-amber-800", children: lastTransportMessage })), schemaResult.error && (_jsx("div", { className: "border-b border-red-300 bg-red-50 px-3 py-2 text-xs text-red-800", children: schemaResult.error })), _jsx("div", { className: "alpaca-graphiql-shell min-h-0 flex-1 bg-white [&_.graphiql-container]:h-full", children: _jsx(GraphiQLIDE, { className: "h-full", fetcher: fetcher, schema: graphiqlSchema, forcedTheme: "light", initialQuery: query, initialVariables: variables, initialHeaders: "", onEditQuery: onQueryChange, onEditVariables: onVariablesChange, onEditHeaders: handleEditHeaders, isHeadersEditorEnabled: false, defaultEditorToolsVisibility: "variables", plugins: plugins, children: _jsx(GraphiQLSyncBridge, { query: query, variables: variables }) }) })] }));
+}

package/dist/Layout.d.ts

@@ -0,0 +1,2 @@
+export declare function Layout(): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=Layout.d.ts.map

package/dist/Layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Layout.d.ts","sourceRoot":"","sources":["../src/Layout.tsx"],"names":[],"mappings":"AAYA,wBAAgB,MAAM,mDA0GrB"}

package/dist/Layout.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { ObjectInspector, ObjectLabel, ObjectRootLabel } from "react-inspector";
+import { CopyButton, getComponentByIdFromHeadlessLayout, SimpleTabs, useEditContext, usePageViewContext, } from "@parhelia/core";
+import { getPageJson } from "./services";
+export function Layout() {
+    const [activeTab, setActiveTab] = useState(0);
+    const [pageLayout, setPageLayout] = useState(null);
+    const editContext = useEditContext();
+    if (!editContext)
+        return null;
+    usePageViewContext({
+        pageItemDescriptor: editContext.item?.descriptor,
+        itemsRepository: editContext.itemsRepository,
+        configuration: editContext.configuration,
+    });
+    useEffect(() => {
+        const loadLayout = async () => {
+            if (!editContext.item)
+                return;
+            const layout = await getPageJson(editContext.item.descriptor);
+            setPageLayout(layout);
+        };
+        loadLayout();
+    }, [editContext.item]);
+    const page = pageLayout;
+    let component = null;
+    if (page) {
+        const selectedComponents = editContext.selection
+            .map((x) => getComponentByIdFromHeadlessLayout(x, page))
+            .filter((x) => x);
+        component = selectedComponents.length === 1 ? selectedComponents[0] : null;
+    }
+    if (!component && !page)
+        return null;
+    const replacer = function (key, value) {
+        if (key === "parentComponent" ||
+            key === "placeholderReference" ||
+            key === "_editor") {
+            return undefined;
+        }
+        return value;
+    };
+    const tabs = [];
+    const defaultNodeRenderer = ({ depth, name, data, isNonenumerable }) => {
+        if (name == "__editor" ||
+            name == "parentComponent" ||
+            name == "placeholderReference") {
+            return null;
+        }
+        return depth === 0 ? (_jsx(ObjectRootLabel, { name: name, data: data })) : (_jsx(ObjectLabel, { name: name, data: data, isNonenumerable: isNonenumerable }));
+    };
+    if (component) {
+        tabs.push({
+            label: "Component",
+            id: "component",
+            content: (_jsx("div", { className: "relative h-full min-h-0", children: _jsx("div", { className: "absolute inset-0 overflow-auto p-2", children: _jsx(ObjectInspector, { data: component, nodeRenderer: defaultNodeRenderer }) }) })),
+        });
+    }
+    tabs.push({
+        label: "Page",
+        id: "page",
+        content: (_jsx("div", { className: "relative h-full min-h-0", children: _jsx("div", { className: "absolute inset-0 overflow-auto p-2", children: _jsx(ObjectInspector, { data: page, nodeRenderer: defaultNodeRenderer }) }) })),
+    });
+    return (_jsxs("div", { className: "relative flex h-full min-h-0 flex-col", children: [_jsx(SimpleTabs, { tabs: tabs, activeTab: activeTab, setActiveTab: setActiveTab, className: "border-gray-3 flex border-b px-2 pt-2 text-xs" }), _jsx("div", { className: "absolute top-2 right-1 h-4 w-4", children: _jsx(CopyButton, { textToCopy: JSON.stringify(activeTab === 0 && component ? component : page, replacer, 2), iconOnly: true }) })] }));
+}

package/dist/graphqlService.d.ts

@@ -0,0 +1,77 @@
+import { GraphQLSchema } from "graphql";
+export type ExecuteGraphQLParams = {
+    query: string;
+    tags?: string[];
+    host?: string;
+    path?: string;
+    language?: string;
+    mode?: string;
+    itemId?: string;
+    version?: number;
+    revalidate?: number;
+    siteName?: string;
+    sessionId?: string;
+    schema?: string;
+};
+export type GraphQLTransport = {
+    requested: "v2";
+    used: "v2" | "v1-fallback";
+    fallbackFromStatus?: number;
+};
+export type GraphQLQueryResult = {
+    data?: any;
+    status: number;
+    errors?: any;
+    transport: GraphQLTransport;
+};
+export type GraphQLSchemaResult = {
+    data?: string;
+    status: number;
+    error?: string;
+    transport: GraphQLTransport;
+};
+export declare const INTROSPECTION_QUERY: string;
+export type GraphQLPanelItem = {
+    id: string;
+    language: string;
+    version: number;
+};
+export type QueryNormalizationResult = {
+    query?: string;
+    warning?: string;
+    error?: string;
+};
+export type GraphiQLExecutionResult = {
+    status?: number;
+    data?: any;
+    errors?: any;
+    error?: string;
+    warning?: string;
+    transport?: GraphQLTransport;
+    compiledQuery?: string;
+};
+export type GraphiQLSchemaResult = GraphiQLExecutionResult & {
+    rawSchemaText?: string;
+    schema?: GraphQLSchema;
+};
+export declare function isSchemaIntrospectionQuery(query: string): boolean;
+export declare function createExplicitItemArgs(item: GraphQLPanelItem): string;
+export declare function createStarterQuery(item: GraphQLPanelItem): string;
+export declare function normalizePanelQuery(query: string, item: GraphQLPanelItem): QueryNormalizationResult;
+export declare function executeGraphQLQuery({ query, host, path, language, mode, itemId, version, siteName, schema, sessionId, }: ExecuteGraphQLParams): Promise<GraphQLQueryResult>;
+export declare function getGraphQLSchema({ id, language, version, mode, siteName, }: {
+    id: string;
+    language?: string;
+    version?: number;
+    mode?: string;
+    siteName?: string;
+}): Promise<GraphQLSchemaResult>;
+export declare function executeGraphiQLRequest(options: {
+    item: GraphQLPanelItem;
+    query: string;
+    variables?: Record<string, unknown> | null;
+    operationName?: string | null;
+}): Promise<GraphiQLExecutionResult>;
+export declare function fetchGraphiQLSchema(item: GraphQLPanelItem): Promise<GraphiQLSchemaResult>;
+export declare function getSchemaContextValue(schemaResult: GraphiQLSchemaResult): string;
+//# sourceMappingURL=graphqlService.d.ts.map

package/dist/graphqlService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlService.d.ts","sourceRoot":"","sources":["../src/graphqlService.ts"],"names":[],"mappings":"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"}

package/dist/graphqlService.js

@@ -0,0 +1,518 @@
+import { get, post } from "@parhelia/core";
+import { buildClientSchema, getIntrospectionQuery, Kind, parse, print, visit, } from "graphql";
+const GRAPHQL_V2_QUERY_URL = "/alpaca/headless/graphql/v2/query";
+const GRAPHQL_V1_QUERY_URL = "/alpaca/headless/graphql";
+const GRAPHQL_V1_SCHEMA_URL = "/alpaca/headless/graphql/schema";
+const V2_TO_V1_FALLBACK_STATUSES = new Set([
+    400, 404, 405, 415, 500, 501, 502, 503, 504,
+]);
+const DEFAULT_INTROSPECTION_QUERY = getIntrospectionQuery({
+    descriptions: true,
+    schemaDescription: true,
+    directiveIsRepeatable: true,
+});
+export const INTROSPECTION_QUERY = DEFAULT_INTROSPECTION_QUERY;
+function shouldFallbackToV1(status) {
+    return V2_TO_V1_FALLBACK_STATUSES.has(status);
+}
+export function isSchemaIntrospectionQuery(query) {
+    return /\b__(schema|type)\b/.test(query);
+}
+export function createExplicitItemArgs(item) {
+    return `id: "${item.id}", language: "${item.language}", version: ${item.version}`;
+}
+function createExplicitItemArgumentNodes(item) {
+    return [
+        {
+            kind: Kind.ARGUMENT,
+            name: { kind: Kind.NAME, value: "id" },
+            value: { kind: Kind.STRING, value: item.id },
+        },
+        {
+            kind: Kind.ARGUMENT,
+            name: { kind: Kind.NAME, value: "language" },
+            value: { kind: Kind.STRING, value: item.language },
+        },
+        {
+            kind: Kind.ARGUMENT,
+            name: { kind: Kind.NAME, value: "version" },
+            value: { kind: Kind.INT, value: String(item.version) },
+        },
+    ];
+}
+export function createStarterQuery(item) {
+    return `query CurrentItem {
+  item(${createExplicitItemArgs(item)}) {
+    id
+    name
+    path
+  }
+}`;
+}
+function hasExplicitItemSelector(query) {
+    return /item\s*\((?=[^)]*\bid\s*:)(?=[^)]*\blanguage\s*:)(?=[^)]*\bversion\s*:)[^)]*\)/i.test(query);
+}
+function rewriteContextShortcutItems(query, item) {
+    let rewritten = false;
+    const explicitArgs = createExplicitItemArgs(item);
+    const rewrittenQuery = query.replace(/item\s*\(([^)]*)\)/gi, (match, args) => {
+        if (/path\s*:\s*["']__[^"']+["']/i.test(args)) {
+            rewritten = true;
+            return `item(${explicitArgs})`;
+        }
+        return match;
+    });
+    return { rewrittenQuery, rewritten };
+}
+function rewriteImplicitItemSelections(query, item) {
+    try {
+        let rewritten = false;
+        const parsed = parse(query);
+        const explicitArgs = createExplicitItemArgumentNodes(item);
+        const rewrittenDocument = visit(parsed, {
+            Field(node, _key, parent, _path, ancestors) {
+                if (node.name.value !== "item" ||
+                    (node.arguments?.length ?? 0) > 0 ||
+                    !node.selectionSet) {
+                    return;
+                }
+                const parentNode = ancestors[ancestors.length - 1];
+                const inOperationSelectionSet = parentNode &&
+                    typeof parentNode === "object" &&
+                    "kind" in parentNode &&
+                    parentNode.kind === Kind.SELECTION_SET &&
+                    ancestors.some((ancestor) => ancestor &&
+                        typeof ancestor === "object" &&
+                        "kind" in ancestor &&
+                        ancestor.kind === Kind.OPERATION_DEFINITION);
+                if (!inOperationSelectionSet) {
+                    return;
+                }
+                rewritten = true;
+                return {
+                    ...node,
+                    arguments: explicitArgs,
+                };
+            },
+        });
+        return {
+            rewrittenQuery: print(rewrittenDocument),
+            rewritten,
+        };
+    }
+    catch {
+        return { rewrittenQuery: query, rewritten: false };
+    }
+}
+export function normalizePanelQuery(query, item) {
+    if (isSchemaIntrospectionQuery(query) || hasExplicitItemSelector(query)) {
+        return { query };
+    }
+    const { rewrittenQuery, rewritten } = rewriteContextShortcutItems(query, item);
+    if (rewritten && hasExplicitItemSelector(rewrittenQuery)) {
+        return {
+            query: rewrittenQuery,
+            warning: "Query used context shortcuts and was rewritten to explicit item(id, language, version).",
+        };
+    }
+    const { rewrittenQuery: implicitItemQuery, rewritten: implicitItemRewritten, } = rewriteImplicitItemSelections(query, item);
+    if (implicitItemRewritten && hasExplicitItemSelector(implicitItemQuery)) {
+        return {
+            query: implicitItemQuery,
+            warning: "Query used item without arguments and was rewritten to explicit item(id, language, version) for the selected base item.",
+        };
+    }
+    if (/\b__page\b/i.test(query)) {
+        return {
+            error: "Context shortcuts like __page are not allowed. Use item(id, language, version) explicitly instead.",
+        };
+    }
+    return { query };
+}
+function getDatabaseFromMode(mode) {
+    const lowered = mode?.toLowerCase();
+    if (lowered === "edit" || lowered === "preview") {
+        return "master";
+    }
+    return "web";
+}
+function getStatus(result) {
+    return result.response?.status ?? 500;
+}
+function getErrorMessage(result) {
+    return result.details || result.summary || result.rawDetails || "Request failed";
+}
+function joinWarnings(...warnings) {
+    return warnings.filter(Boolean).join(" ");
+}
+function parseJsonSafely(text) {
+    if (!text.trim()) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getOperationDefinitions(document) {
+    return document.definitions.filter((definition) => definition.kind === Kind.OPERATION_DEFINITION);
+}
+function getSelectedOperation(document, operationName) {
+    const operations = getOperationDefinitions(document);
+    if (operationName) {
+        const matchingOperation = operations.find((operation) => operation.name?.value === operationName);
+        if (!matchingOperation) {
+            throw new Error(`Could not find operation "${operationName}" in the current document.`);
+        }
+        return matchingOperation;
+    }
+    if (operations.length !== 1) {
+        throw new Error("Alpaca GraphQL execution expects a single operation. Select exactly one operation before running the query.");
+    }
+    const selectedOperation = operations[0];
+    if (!selectedOperation) {
+        throw new Error("No GraphQL operation was found in the current document.");
+    }
+    return selectedOperation;
+}
+function collectReferencedFragments(definition, fragmentMap, visited = new Set()) {
+    visit(definition, {
+        FragmentSpread(node) {
+            if (visited.has(node.name.value)) {
+                return;
+            }
+            visited.add(node.name.value);
+            const fragment = fragmentMap.get(node.name.value);
+            if (fragment) {
+                collectReferencedFragments(fragment, fragmentMap, visited);
+            }
+        },
+    });
+    return visited;
+}
+function createValueNode(value) {
+    if (value === null) {
+        return { kind: Kind.NULL };
+    }
+    if (Array.isArray(value)) {
+        return {
+            kind: Kind.LIST,
+            values: value.map((entry) => createValueNode(entry)),
+        };
+    }
+    switch (typeof value) {
+        case "boolean":
+            return { kind: Kind.BOOLEAN, value };
+        case "number":
+            if (!Number.isFinite(value)) {
+                throw new Error("Only finite numbers can be inlined into GraphQL queries.");
+            }
+            return Number.isInteger(value)
+                ? { kind: Kind.INT, value: String(value) }
+                : { kind: Kind.FLOAT, value: String(value) };
+        case "string":
+            return { kind: Kind.STRING, value };
+        case "object":
+            return {
+                kind: Kind.OBJECT,
+                fields: Object.entries(value).map(([name, entry]) => ({
+                    kind: Kind.OBJECT_FIELD,
+                    name: { kind: Kind.NAME, value: name },
+                    value: createValueNode(entry),
+                })),
+            };
+        default:
+            throw new Error(`Unsupported variable value type "${typeof value}" for GraphQL inlining.`);
+    }
+}
+function compileQueryForExecution(options) {
+    try {
+        const document = parse(options.query);
+        const selectedOperation = getSelectedOperation(document, options.operationName);
+        const fragmentMap = new Map(document.definitions
+            .filter((definition) => definition.kind === Kind.FRAGMENT_DEFINITION)
+            .map((definition) => [definition.name.value, definition]));
+        const referencedFragments = collectReferencedFragments(selectedOperation, fragmentMap);
+        const reducedDocument = {
+            kind: Kind.DOCUMENT,
+            definitions: [
+                selectedOperation,
+                ...Array.from(referencedFragments)
+                    .map((name) => fragmentMap.get(name))
+                    .filter((definition) => Boolean(definition)),
+            ],
+        };
+        const variableDefinitions = selectedOperation.variableDefinitions ?? [];
+        const hasVariables = variableDefinitions.length > 0 &&
+            variableDefinitions.some((definition) => options.variables?.[definition.variable.name.value] !== undefined ||
+                definition.defaultValue !== undefined);
+        if (!hasVariables) {
+            return { ok: true, query: print(reducedDocument) };
+        }
+        const inlinedDocument = visit(reducedDocument, {
+            OperationDefinition(node) {
+                return {
+                    ...node,
+                    variableDefinitions: [],
+                };
+            },
+            Variable(node) {
+                const definition = variableDefinitions.find((entry) => entry.variable.name.value === node.name.value);
+                if (!definition) {
+                    throw new Error(`Unknown variable "${node.name.value}" in GraphQL query.`);
+                }
+                const explicitValue = options.variables?.[node.name.value];
+                if (explicitValue !== undefined) {
+                    return createValueNode(explicitValue);
+                }
+                if (definition.defaultValue) {
+                    return definition.defaultValue;
+                }
+                throw new Error(`Variable "$${node.name.value}" is required, but Alpaca GraphQL requests do not accept a separate variables payload.`);
+            },
+        });
+        return {
+            ok: true,
+            query: print(inlinedDocument),
+            warning: "Variables were inlined client-side because the Alpaca GraphQL endpoints do not accept a separate variables payload.",
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export async function executeGraphQLQuery({ query, host, path, language, mode, itemId, version, siteName, schema, sessionId, }) {
+    const modeValue = mode || "normal";
+    const v2Response = await post(GRAPHQL_V2_QUERY_URL, {
+        Query: query,
+        Schema: schema,
+        ItemContext: {
+            Database: getDatabaseFromMode(modeValue),
+            Language: language,
+            SiteName: siteName || "website",
+            ItemId: itemId,
+            Mode: modeValue,
+        },
+    }, sessionId);
+    if (v2Response.type === "success") {
+        if (v2Response.data?.errors) {
+            return {
+                status: 400,
+                errors: v2Response.data.errors,
+                transport: { requested: "v2", used: "v2" },
+            };
+        }
+        return {
+            data: v2Response.data?.data,
+            status: getStatus(v2Response),
+            transport: { requested: "v2", used: "v2" },
+        };
+    }
+    const v2Status = getStatus(v2Response);
+    if (!shouldFallbackToV1(v2Status)) {
+        return {
+            status: v2Status,
+            errors: [{ message: getErrorMessage(v2Response) }],
+            transport: { requested: "v2", used: "v2" },
+        };
+    }
+    const v1Response = await post(GRAPHQL_V1_QUERY_URL, {
+        Query: query,
+        Host: host,
+        Path: path,
+        ItemId: itemId,
+        Language: language,
+        Version: version,
+        Mode: mode,
+        SiteName: siteName,
+        Schema: schema,
+    }, sessionId);
+    if (v1Response.type !== "success") {
+        return {
+            status: getStatus(v1Response),
+            errors: [{ message: getErrorMessage(v1Response) }],
+            transport: {
+                requested: "v2",
+                used: "v1-fallback",
+                fallbackFromStatus: v2Status,
+            },
+        };
+    }
+    if (v1Response.data?.errors) {
+        return {
+            status: 400,
+            errors: v1Response.data.errors,
+            transport: {
+                requested: "v2",
+                used: "v1-fallback",
+                fallbackFromStatus: v2Status,
+            },
+        };
+    }
+    console.warn("GraphQL v2 request fell back to v1", JSON.stringify({
+        v2Status,
+        v1Status: getStatus(v1Response),
+        endpoint: GRAPHQL_V2_QUERY_URL,
+    }));
+    return {
+        data: v1Response.data?.data,
+        status: getStatus(v1Response),
+        transport: {
+            requested: "v2",
+            used: "v1-fallback",
+            fallbackFromStatus: v2Status,
+        },
+    };
+}
+export async function getGraphQLSchema({ id, language, version, mode, siteName, }) {
+    const v2Response = await executeGraphQLQuery({
+        query: DEFAULT_INTROSPECTION_QUERY,
+        itemId: id,
+        language,
+        version,
+        mode: mode || "edit",
+        siteName,
+    });
+    if (v2Response.status === 200 && !v2Response.errors) {
+        return {
+            data: JSON.stringify(v2Response.data ?? {}, null, 2),
+            status: v2Response.status,
+            transport: v2Response.transport,
+        };
+    }
+    if (!shouldFallbackToV1(v2Response.status)) {
+        return {
+            status: v2Response.status,
+            error: v2Response.errors?.[0]?.message || "Schema introspection failed",
+            transport: v2Response.transport,
+        };
+    }
+    const v1Url = `${GRAPHQL_V1_SCHEMA_URL}?id=${encodeURIComponent(id)}`;
+    const v1Response = await get(v1Url);
+    if (v1Response.type !== "success") {
+        return {
+            status: getStatus(v1Response),
+            error: getErrorMessage(v1Response),
+            transport: {
+                requested: "v2",
+                used: "v1-fallback",
+                fallbackFromStatus: v2Response.status,
+            },
+        };
+    }
+    const schemaText = v1Response.data ?? (await v1Response.response.text());
+    console.warn("GraphQL schema request fell back to v1", JSON.stringify({
+        v2Status: v2Response.status,
+        v1Status: getStatus(v1Response),
+        endpoint: v1Url,
+    }));
+    return {
+        data: schemaText,
+        status: getStatus(v1Response),
+        transport: {
+            requested: "v2",
+            used: "v1-fallback",
+            fallbackFromStatus: v2Response.status,
+        },
+    };
+}
+export async function executeGraphiQLRequest(options) {
+    const compiledQuery = compileQueryForExecution({
+        query: options.query,
+        variables: options.variables,
+        operationName: options.operationName,
+    });
+    if (!compiledQuery.ok) {
+        return { status: 400, error: compiledQuery.error };
+    }
+    const normalized = normalizePanelQuery(compiledQuery.query, options.item);
+    if (normalized.error) {
+        return {
+            status: 400,
+            error: normalized.error,
+            compiledQuery: compiledQuery.query,
+        };
+    }
+    const effectiveQuery = normalized.query ?? compiledQuery.query;
+    const warning = joinWarnings(normalized.warning, compiledQuery.warning);
+    try {
+        const response = await executeGraphQLQuery({
+            query: effectiveQuery,
+            itemId: options.item.id,
+            language: options.item.language,
+            version: options.item.version,
+            mode: "edit",
+            siteName: "website",
+            schema: "Default",
+        });
+        return {
+            ...response,
+            error: response.status && response.status !== 200 && !response.errors
+                ? "GraphQL request failed"
+                : undefined,
+            warning,
+            compiledQuery: effectiveQuery,
+        };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            warning,
+            compiledQuery: effectiveQuery,
+        };
+    }
+}
+export async function fetchGraphiQLSchema(item) {
+    const response = await getGraphQLSchema({
+        id: item.id,
+        language: item.language,
+        version: item.version,
+        mode: "edit",
+        siteName: "website",
+    });
+    if (response.error) {
+        return {
+            status: response.status,
+            error: response.error,
+            transport: response.transport,
+        };
+    }
+    try {
+        const rawSchemaText = response.data ?? "";
+        const parsedSchema = rawSchemaText ? JSON.parse(rawSchemaText) : undefined;
+        return {
+            data: parsedSchema,
+            schema: parsedSchema ? buildClientSchema(parsedSchema) : undefined,
+            status: response.status,
+            transport: response.transport,
+            rawSchemaText,
+        };
+    }
+    catch (error) {
+        return {
+            status: response.status,
+            error: error instanceof Error
+                ? `Schema parsing failed: ${error.message}`
+                : "Schema parsing failed.",
+            transport: response.transport,
+            rawSchemaText: response.data,
+        };
+    }
+}
+export function getSchemaContextValue(schemaResult) {
+    if (schemaResult.data) {
+        return JSON.stringify(schemaResult.data, null, 2);
+    }
+    if (schemaResult.rawSchemaText) {
+        return schemaResult.rawSchemaText;
+    }
+    if (schemaResult.error) {
+        return schemaResult.error;
+    }
+    return "";
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { EditorConfiguration } from "@parhelia/core";
+export declare function configureAlpacaDebug(configuration: EditorConfiguration): EditorConfiguration;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EAIpB,MAAM,gBAAgB,CAAC;AAsCxB,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,mBAAmB,uBAqBtE"}

package/dist/index.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { PanelsTopLeft } from "lucide-react";
+import { GraphQLIcon, JsonIcon, } from "@parhelia/core";
+import { Layout } from "./Layout";
+import { GraphQL } from "./GraphQL";
+const layoutDebugSidebar = {
+    id: "layout",
+    title: "Layout",
+    icon: _jsx(PanelsTopLeft, { strokeWidth: 1 }),
+    position: "left",
+    sortOrder: 100,
+    panels: [
+        {
+            name: "layout",
+            icon: _jsx(JsonIcon, {}),
+            title: "Layout",
+            content: _jsx(Layout, {}),
+            initialSize: 100,
+        },
+    ],
+};
+const graphqlSidebar = {
+    id: "graphql",
+    title: "GraphQL",
+    icon: _jsx(GraphQLIcon, {}),
+    position: "left",
+    sortOrder: 101,
+    panels: [
+        {
+            name: "graphql",
+            icon: _jsx(GraphQLIcon, {}),
+            title: "GraphQL",
+            content: _jsx(GraphQL, {}),
+            initialSize: 100,
+        },
+    ],
+};
+export function configureAlpacaDebug(configuration) {
+    const sidebars = (configuration.editor?.sidebars || []).filter((s) => s.id !== "debug");
+    const hasLayoutDebugSidebar = sidebars.some((s) => s.id === layoutDebugSidebar.id);
+    const hasGraphqlSidebar = sidebars.some((s) => s.id === graphqlSidebar.id);
+    const nextSidebars = [...sidebars];
+    if (!hasLayoutDebugSidebar)
+        nextSidebars.push(layoutDebugSidebar);
+    if (!hasGraphqlSidebar)
+        nextSidebars.push(graphqlSidebar);
+    configuration.editor = {
+        ...configuration.editor,
+        sidebars: nextSidebars,
+    };
+    return configuration;
+}

package/dist/services.d.ts

@@ -0,0 +1,3 @@
+import { ItemDescriptor } from "@parhelia/core";
+export declare function getPageJson(page: ItemDescriptor): Promise<any>;
+//# sourceMappingURL=services.d.ts.map

package/dist/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../src/services.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAQ,MAAM,gBAAgB,CAAC;AAEtD,wBAAsB,WAAW,CAAC,IAAI,EAAE,cAAc,gBAQrD"}

package/dist/services.js

@@ -0,0 +1,10 @@
+import { post } from "@parhelia/core";
+export async function getPageJson(page) {
+    const response = await post("/alpaca/headless/layout", {
+        itemId: page.id,
+        language: page.language,
+        version: page.version,
+        mode: "preview",
+    });
+    return response.data?.page;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@parhelia/alpaca",
+  "version": "0.1.12451",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "development": "./src/index.tsx",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./styles.css": "./styles.css"
+  },
+  "files": [
+    "dist/",
+    "styles.css",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "lint": "eslint . --max-warnings 0",
+    "check-types": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "@tailwindcss/postcss": "^4.1.18",
+    "@types/node": "^22.13.9",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "eslint": "^9.22.0",
+    "tailwindcss": "^4.1.18",
+    "typescript": "5.8.2"
+  },
+  "dependencies": {
+    "@graphiql/plugin-explorer": "^5.1.1",
+    "@graphiql/react": "^0.37.3",
+    "@parhelia/core": "*",
+    "@uiw/react-textarea-code-editor": "^3.1.1",
+    "graphiql": "^5.2.2",
+    "graphql": "^15.10.1",
+    "lucide-react": "^0.486.0",
+    "postcss": "^8.5.3",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "react-inspector": "^6.0.2"
+  },
+  "overrides": {
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3"
+  }
+}

package/styles.css

@@ -0,0 +1,8 @@
+/*
+  This package intentionally does NOT ship a Tailwind utilities bundle.
+  The consuming app should generate utilities by scanning this package's
+  compiled JS output.
+*/
+
+@source "./src/**/*.{js,ts,jsx,tsx}";
+@source "./dist/**/*.js";