camox 0.0.0 → 0.1.2-alpha.2

package/dist/features/provider/components/CamoxAppContext.d.ts

@@ -0,0 +1,371 @@
+import { CamoxApp } from '../../../core/createApp';
+import * as React from "react";
+export declare const CamoxAppProvider: ({ app, children, }: {
+    app: CamoxApp;
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useCamoxApp(): {
+    getBlocks(): {
+        Component: ({ blockData, mode, isFirstBlock, showAddBlockTop, showAddBlockBottom, addBlockAfterPosition, }: import('../../../core/createBlock').BlockComponentProps<{
+            [x: string]: unknown;
+        }>) => import("react/jsx-runtime").JSX.Element;
+        Detached: ({ children }: {
+            children: React.ReactNode;
+        }) => React.JSX.Element;
+        Field: <K extends never>({ name, children, }: {
+            name: K;
+            children: (content: React.ReactNode) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        Embed: <K extends never>({ name, children, }: {
+            name: K;
+            children: (url: string) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        Link: <K extends never>({ name, children, }: {
+            name: K;
+            children: (link: {
+                text: string;
+                href: string;
+                newTab: boolean;
+            }) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        Image: <K extends never>({ name, children, }: {
+            name: K;
+            children: (image: import('../../../core/lib/contentType').ImageValue) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        File: <K extends never>({ name, children, }: {
+            name: K;
+            children: (file: import('../../../core/lib/contentType').FileValue) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        Repeater: <K extends never>({ name, children, }: {
+            name: K;
+            children: (item: {
+                Field: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as ({}[K] extends (infer U)[] ? U : never)[F_1] extends string ? F_1 : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (content: React.ReactNode) => React.ReactNode;
+                }) => React.ReactNode;
+                Link: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as ({}[K] extends (infer U)[] ? U : never)[F_1] extends import('../../../core/lib/contentType').LinkValue ? F_1 : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (link: {
+                        text: string;
+                        href: string;
+                        newTab: boolean;
+                    }) => React.ReactNode;
+                }) => React.ReactNode;
+                Embed: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as ({}[K] extends (infer U)[] ? U : never)[F_1] extends import('../../../core/lib/contentType').EmbedURL ? F_1 : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (url: string) => React.ReactNode;
+                }) => React.ReactNode;
+                Image: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as import('../../../core/lib/contentType').ImageValue extends ({}[K] extends (infer U)[] ? U : never)[F_1] ? ({}[K] extends (infer U)[] ? U : never)[F_1] extends ({}[K] extends (infer U)[] ? U : never)[F_1] & {
+                    url: string;
+                    alt: string;
+                    filename: string;
+                    mimeType: string;
+                    _fileId?: string;
+                } & {
+                    readonly __brand: "ImageValue";
+                } ? F_1 : never : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (image: import('../../../core/lib/contentType').ImageValue) => React.ReactNode;
+                }) => React.ReactNode;
+                File: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as import('../../../core/lib/contentType').FileValue extends ({}[K] extends (infer U)[] ? U : never)[F_1] ? ({}[K] extends (infer U)[] ? U : never)[F_1] extends ({}[K] extends (infer U)[] ? U : never)[F_1] & {
+                    url: string;
+                    alt: string;
+                    filename: string;
+                    mimeType: string;
+                    _fileId?: string;
+                } & {
+                    readonly __brand: "FileValue";
+                } ? F_1 : never : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (file: import('../../../core/lib/contentType').FileValue) => React.ReactNode;
+                }) => React.ReactNode;
+                Repeater: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as ({}[K] extends (infer U)[] ? U : never)[F_1] extends any[] ? F_1 : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (item: {
+                        Field: (props: {
+                            name: string;
+                            children: (content: any) => React.ReactNode;
+                        }) => React.ReactNode;
+                        Link: (props: {
+                            name: string;
+                            children: (link: {
+                                text: string;
+                                href: string;
+                                newTab: boolean;
+                            }) => React.ReactNode;
+                        }) => React.ReactNode;
+                        Embed: (props: {
+                            name: string;
+                            children: (url: string) => React.ReactNode;
+                        }) => React.ReactNode;
+                        Image: (props: {
+                            name: string;
+                            children: (image: import('../../../core/lib/contentType').ImageValue) => React.ReactNode;
+                        }) => React.ReactNode;
+                        File: (props: {
+                            name: string;
+                            children: (file: import('../../../core/lib/contentType').FileValue) => React.ReactNode;
+                        }) => React.ReactNode;
+                        Repeater: (props: {
+                            name: string;
+                            children: (item: any, index: number) => React.ReactNode;
+                        }) => React.ReactNode;
+                    }, index: number) => React.ReactNode;
+                }) => React.ReactNode;
+            }, index: number) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        useSetting: <K extends string>(name: K) => unknown;
+        id: string;
+        title: string;
+        description: string;
+        contentSchema: {
+            type: "object";
+            title: string;
+            description: string;
+            properties: Record<string, import('@sinclair/typebox').TSchema>;
+            required: string[];
+            toMarkdown: readonly string[];
+        };
+        settingsSchema: {
+            type: "object";
+            properties: Record<string, import('@sinclair/typebox').TSchema>;
+            required: string[];
+        } | undefined;
+        getInitialContent: () => {
+            [x: string]: unknown;
+        };
+        getInitialSettings: () => {
+            [x: string]: unknown;
+        };
+        layoutOnly: boolean;
+    }[];
+    getBlockById(id: string): {
+        Component: ({ blockData, mode, isFirstBlock, showAddBlockTop, showAddBlockBottom, addBlockAfterPosition, }: import('../../../core/createBlock').BlockComponentProps<{
+            [x: string]: unknown;
+        }>) => import("react/jsx-runtime").JSX.Element;
+        Detached: ({ children }: {
+            children: React.ReactNode;
+        }) => React.JSX.Element;
+        Field: <K extends never>({ name, children, }: {
+            name: K;
+            children: (content: React.ReactNode) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        Embed: <K extends never>({ name, children, }: {
+            name: K;
+            children: (url: string) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        Link: <K extends never>({ name, children, }: {
+            name: K;
+            children: (link: {
+                text: string;
+                href: string;
+                newTab: boolean;
+            }) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        Image: <K extends never>({ name, children, }: {
+            name: K;
+            children: (image: import('../../../core/lib/contentType').ImageValue) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        File: <K extends never>({ name, children, }: {
+            name: K;
+            children: (file: import('../../../core/lib/contentType').FileValue) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        Repeater: <K extends never>({ name, children, }: {
+            name: K;
+            children: (item: {
+                Field: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as ({}[K] extends (infer U)[] ? U : never)[F_1] extends string ? F_1 : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (content: React.ReactNode) => React.ReactNode;
+                }) => React.ReactNode;
+                Link: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as ({}[K] extends (infer U)[] ? U : never)[F_1] extends import('../../../core/lib/contentType').LinkValue ? F_1 : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (link: {
+                        text: string;
+                        href: string;
+                        newTab: boolean;
+                    }) => React.ReactNode;
+                }) => React.ReactNode;
+                Embed: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as ({}[K] extends (infer U)[] ? U : never)[F_1] extends import('../../../core/lib/contentType').EmbedURL ? F_1 : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (url: string) => React.ReactNode;
+                }) => React.ReactNode;
+                Image: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as import('../../../core/lib/contentType').ImageValue extends ({}[K] extends (infer U)[] ? U : never)[F_1] ? ({}[K] extends (infer U)[] ? U : never)[F_1] extends ({}[K] extends (infer U)[] ? U : never)[F_1] & {
+                    url: string;
+                    alt: string;
+                    filename: string;
+                    mimeType: string;
+                    _fileId?: string;
+                } & {
+                    readonly __brand: "ImageValue";
+                } ? F_1 : never : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (image: import('../../../core/lib/contentType').ImageValue) => React.ReactNode;
+                }) => React.ReactNode;
+                File: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as import('../../../core/lib/contentType').FileValue extends ({}[K] extends (infer U)[] ? U : never)[F_1] ? ({}[K] extends (infer U)[] ? U : never)[F_1] extends ({}[K] extends (infer U)[] ? U : never)[F_1] & {
+                    url: string;
+                    alt: string;
+                    filename: string;
+                    mimeType: string;
+                    _fileId?: string;
+                } & {
+                    readonly __brand: "FileValue";
+                } ? F_1 : never : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (file: import('../../../core/lib/contentType').FileValue) => React.ReactNode;
+                }) => React.ReactNode;
+                Repeater: <F extends keyof { [F_1 in keyof ({}[K] extends (infer U)[] ? U : never) as ({}[K] extends (infer U)[] ? U : never)[F_1] extends any[] ? F_1 : never]: ({}[K] extends (infer U)[] ? U : never)[F_1]; }>(props: {
+                    name: F;
+                    children: (item: {
+                        Field: (props: {
+                            name: string;
+                            children: (content: any) => React.ReactNode;
+                        }) => React.ReactNode;
+                        Link: (props: {
+                            name: string;
+                            children: (link: {
+                                text: string;
+                                href: string;
+                                newTab: boolean;
+                            }) => React.ReactNode;
+                        }) => React.ReactNode;
+                        Embed: (props: {
+                            name: string;
+                            children: (url: string) => React.ReactNode;
+                        }) => React.ReactNode;
+                        Image: (props: {
+                            name: string;
+                            children: (image: import('../../../core/lib/contentType').ImageValue) => React.ReactNode;
+                        }) => React.ReactNode;
+                        File: (props: {
+                            name: string;
+                            children: (file: import('../../../core/lib/contentType').FileValue) => React.ReactNode;
+                        }) => React.ReactNode;
+                        Repeater: (props: {
+                            name: string;
+                            children: (item: any, index: number) => React.ReactNode;
+                        }) => React.ReactNode;
+                    }, index: number) => React.ReactNode;
+                }) => React.ReactNode;
+            }, index: number) => React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        useSetting: <K extends string>(name: K) => unknown;
+        id: string;
+        title: string;
+        description: string;
+        contentSchema: {
+            type: "object";
+            title: string;
+            description: string;
+            properties: Record<string, import('@sinclair/typebox').TSchema>;
+            required: string[];
+            toMarkdown: readonly string[];
+        };
+        settingsSchema: {
+            type: "object";
+            properties: Record<string, import('@sinclair/typebox').TSchema>;
+            required: string[];
+        } | undefined;
+        getInitialContent: () => {
+            [x: string]: unknown;
+        };
+        getInitialSettings: () => {
+            [x: string]: unknown;
+        };
+        layoutOnly: boolean;
+    } | undefined;
+    getLayouts(): {
+        id: string;
+        title: string;
+        description: string;
+        buildMetaTitle: (params: {
+            pageMetaTitle: string;
+            projectName: string;
+            pageFullPath: string;
+        }) => string;
+        buildOgImage: ((params: import('../../../core/createLayout').OgImageParams) => Promise<Response>) | undefined;
+        blockDefinitions: ({
+            type: string;
+            content: Record<string, unknown>;
+            settings: Record<string, unknown>;
+            placement: "before";
+        } | {
+            type: string;
+            content: Record<string, unknown>;
+            settings: Record<string, unknown>;
+            placement: "after";
+        })[];
+        component: React.ComponentType<{
+            children: React.ReactNode;
+        }>;
+        Provider: ({ layoutBlocks, children, }: {
+            layoutBlocks: Record<string, import('../../../core/createLayout').LayoutBlockData>;
+            children: React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        blocks: Record<string, React.ComponentType>;
+    }[];
+    getLayoutById(id: string): {
+        id: string;
+        title: string;
+        description: string;
+        buildMetaTitle: (params: {
+            pageMetaTitle: string;
+            projectName: string;
+            pageFullPath: string;
+        }) => string;
+        buildOgImage: ((params: import('../../../core/createLayout').OgImageParams) => Promise<Response>) | undefined;
+        blockDefinitions: ({
+            type: string;
+            content: Record<string, unknown>;
+            settings: Record<string, unknown>;
+            placement: "before";
+        } | {
+            type: string;
+            content: Record<string, unknown>;
+            settings: Record<string, unknown>;
+            placement: "after";
+        })[];
+        component: React.ComponentType<{
+            children: React.ReactNode;
+        }>;
+        Provider: ({ layoutBlocks, children, }: {
+            layoutBlocks: Record<string, import('../../../core/createLayout').LayoutBlockData>;
+            children: React.ReactNode;
+        }) => import("react/jsx-runtime").JSX.Element;
+        blocks: Record<string, React.ComponentType>;
+    } | undefined;
+    getSerializableDefinitions(): {
+        blockId: string;
+        title: string;
+        description: string;
+        contentSchema: {
+            type: "object";
+            title: string;
+            description: string;
+            properties: Record<string, import('@sinclair/typebox').TSchema>;
+            required: string[];
+            toMarkdown: readonly string[];
+        };
+        settingsSchema: {
+            type: "object";
+            properties: Record<string, import('@sinclair/typebox').TSchema>;
+            required: string[];
+        } | undefined;
+        layoutOnly: true | undefined;
+    }[];
+    getSerializableLayoutDefinitions(): {
+        layoutId: string;
+        description: string;
+        blocks: ({
+            type: string;
+            content: Record<string, unknown>;
+            settings: Record<string, unknown>;
+            placement: "before";
+        } | {
+            type: string;
+            content: Record<string, unknown>;
+            settings: Record<string, unknown>;
+            placement: "after";
+        })[];
+    }[];
+};
+//# sourceMappingURL=CamoxAppContext.d.ts.map

package/dist/features/provider/components/CamoxAppContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CamoxAppContext.d.ts","sourceRoot":"","sources":["../../../../src/features/provider/components/CamoxAppContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAIxD,eAAO,MAAM,gBAAgB,GAAI,oBAG9B;IACD,GAAG,EAAE,QAAQ,CAAC;IACd,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,4CAEA,CAAC;AAEF,wBAAgB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ1B"}

package/dist/features/provider/components/CamoxAppContext.js

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/features/provider/components/CamoxAppContext.tsx
+var CamoxAppContext = React.createContext(void 0);
+var CamoxAppProvider = ({ app, children }) => {
+	return /* @__PURE__ */ jsx(CamoxAppContext.Provider, {
+		value: app,
+		children
+	});
+};
+function useCamoxApp() {
+	const context = React.use(CamoxAppContext);
+	if (!context) throw new Error("useCamoxApp must be used within a CamoxAppProvider");
+	return context;
+}
+//#endregion
+export { CamoxAppProvider, useCamoxApp };

package/dist/features/provider/components/CommandPalette.d.ts

@@ -0,0 +1,3 @@
+export declare function CommandPalette(): import("react/jsx-runtime").JSX.Element;
+export declare function useCommandPaletteActions(): void;
+//# sourceMappingURL=CommandPalette.d.ts.map

package/dist/features/provider/components/CommandPalette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandPalette.d.ts","sourceRoot":"","sources":["../../../../src/features/provider/components/CommandPalette.tsx"],"names":[],"mappings":"AAiBA,wBAAgB,cAAc,4CA4H7B;AAED,wBAAgB,wBAAwB,SAwBvC"}

package/dist/features/provider/components/CommandPalette.js

@@ -0,0 +1,127 @@
+import { actionsStore } from "../actionsStore.js";
+import { studioStore } from "../../studio/studioStore.js";
+import { useSelector } from "@xstate/store/react";
+import * as React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn, formatShortcut } from "@/lib/utils";
+import * as icons from "lucide-react";
+import { CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from "@camox/ui/command";
+//#region src/features/provider/components/CommandPalette.tsx
+function CommandPalette() {
+	const isOpen = useSelector(studioStore, (state) => state.context.isCommandPaletteOpen);
+	const [search, setSearch] = React.useState("");
+	const [value, setValue] = React.useState("");
+	const actions = useSelector(actionsStore, (state) => state.context.actions);
+	const page = useSelector(studioStore, (state) => state.context.commandPalettePages).at(-1);
+	const groupedActions = React.useMemo(() => {
+		const availableActions = actions.filter((action) => {
+			if (!action.checkIfAvailable()) return false;
+			if (action.groupLabel === "Invisible") return false;
+			if (page) return action.parentActionId === page;
+			if (search.length > 0) return true;
+			return !action.parentActionId;
+		});
+		const groups = /* @__PURE__ */ new Map();
+		for (const action of availableActions) {
+			const existing = groups.get(action.groupLabel) || [];
+			groups.set(action.groupLabel, [...existing, action]);
+		}
+		const groupOrder = [
+			"Preview",
+			"Navigation",
+			"Studio"
+		];
+		const sortedGroups = /* @__PURE__ */ new Map();
+		for (const groupLabel of groupOrder) if (groups.has(groupLabel)) sortedGroups.set(groupLabel, groups.get(groupLabel));
+		return sortedGroups;
+	}, [
+		actions,
+		page,
+		search
+	]);
+	React.useEffect(() => {
+		if (page) {
+			const firstChild = actions.find((a) => a.parentActionId === page && a.checkIfAvailable());
+			if (firstChild) setValue(firstChild.id);
+		}
+	}, [page, actions]);
+	const handleSelect = (actionId) => {
+		const action = actions.find((a) => a.id === actionId);
+		if (!action) return;
+		action.execute();
+		setSearch("");
+		if (action.hasChildren) studioStore.send({
+			type: "pushCommandPalettePage",
+			page: action.id
+		});
+		else studioStore.send({ type: "closeCommandPalette" });
+	};
+	const handleOpenChange = (open) => {
+		if (open) studioStore.send({ type: "openCommandPalette" });
+		else {
+			setValue("");
+			studioStore.send({ type: "closeCommandPalette" });
+		}
+	};
+	return /* @__PURE__ */ jsxs(CommandDialog, {
+		open: isOpen,
+		onOpenChange: handleOpenChange,
+		value,
+		onValueChange: setValue,
+		children: [/* @__PURE__ */ jsx(CommandInput, {
+			value: search,
+			onValueChange: setSearch,
+			placeholder: "Type a command or search...",
+			onKeyDown: (e) => {
+				if (e.key === "Escape" || e.key === "Backspace" && !search) {
+					e.preventDefault();
+					studioStore.send({ type: "popCommandPalettePage" });
+				}
+			}
+		}), /* @__PURE__ */ jsxs(CommandList, { children: [/* @__PURE__ */ jsx(CommandEmpty, { children: "No results found." }), Array.from(groupedActions.entries()).map(([groupLabel, groupActions]) => /* @__PURE__ */ jsx(CommandGroup, {
+			heading: groupLabel,
+			children: groupActions.map((action) => {
+				const Icon = action.icon ? icons[action.icon] : null;
+				return /* @__PURE__ */ jsxs(CommandItem, {
+					onSelect: () => handleSelect(action.id),
+					className: "justify-between",
+					children: [/* @__PURE__ */ jsxs("div", {
+						className: "flex items-center gap-2",
+						children: [Icon && /* @__PURE__ */ jsx(Icon, { className: "size-4" }), /* @__PURE__ */ jsx("span", {
+							className: cn(!Icon && "ml-7"),
+							children: action.label
+						})]
+					}), action.shortcut && formatShortcut(action.shortcut)]
+				}, action.id);
+			})
+		}, groupLabel))] })]
+	});
+}
+function useCommandPaletteActions() {
+	React.useEffect(() => {
+		actionsStore.send({
+			type: "registerAction",
+			action: {
+				id: "toggle-command-palette",
+				label: "Toggle command palette",
+				groupLabel: "Invisible",
+				checkIfAvailable: () => true,
+				execute: () => {
+					studioStore.send({ type: "toggleCommandPalette" });
+				},
+				shortcut: {
+					key: "k",
+					withMeta: true
+				}
+			}
+		});
+		return () => {
+			actionsStore.send({
+				type: "unregisterAction",
+				id: "toggle-command-palette"
+			});
+		};
+	}, []);
+}
+//#endregion
+export { CommandPalette, useCommandPaletteActions };

package/dist/features/provider/useAdminShortcuts.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook that listens for global keyboard shortcuts defined in the actionsStore
+ */
+export declare function useAdminShortcuts(): void;
+//# sourceMappingURL=useAdminShortcuts.d.ts.map

package/dist/features/provider/useAdminShortcuts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAdminShortcuts.d.ts","sourceRoot":"","sources":["../../../src/features/provider/useAdminShortcuts.tsx"],"names":[],"mappings":"AAQA;;GAEG;AACH,wBAAgB,iBAAiB,SAkHhC"}

package/dist/features/provider/useAdminShortcuts.js

@@ -0,0 +1,83 @@
+import { previewStore } from "../preview/previewStore.js";
+import { actionsStore } from "./actionsStore.js";
+import { useSelector } from "@xstate/store/react";
+import * as React from "react";
+import { checkIfInputFocused } from "@/lib/utils";
+//#region src/features/provider/useAdminShortcuts.tsx
+/**
+* Hook that listens for global keyboard shortcuts defined in the actionsStore
+*/
+function useAdminShortcuts() {
+	const actions = useSelector(actionsStore, (state) => state.context.actions);
+	const previousLockState = React.useRef(null);
+	const lockKeyDownTime = React.useRef(null);
+	const HOLD_THRESHOLD_MS = 300;
+	React.useEffect(() => {
+		const handleKeyDown = (event) => {
+			if (event.key.toLowerCase() === "l" && !event.metaKey && !event.altKey && !event.shiftKey) {
+				if (event.repeat) return;
+				if (checkIfInputFocused()) return;
+				event.preventDefault();
+				if (previousLockState.current === null) {
+					lockKeyDownTime.current = Date.now();
+					previousLockState.current = previewStore.getSnapshot().context.isContentLocked;
+					if (!previousLockState.current) previewStore.send({ type: "toggleLockContent" });
+				}
+				return;
+			}
+			const matchingAction = actions.find((action) => {
+				if (!action.shortcut) return false;
+				if (!action.checkIfAvailable()) return false;
+				const { key, withMeta, withAlt, withShift } = action.shortcut;
+				return (withAlt && key.length === 1 && /[a-z]/i.test(key) ? event.code === `Key${key.toUpperCase()}` : key.toLowerCase() === event.key.toLowerCase()) && !!withMeta === (event.metaKey || event.ctrlKey) && !!withAlt === event.altKey && !!withShift === event.shiftKey;
+			});
+			if (!matchingAction) return;
+			const shortcut = matchingAction.shortcut;
+			if (checkIfInputFocused()) {
+				if (!shortcut.withMeta && !shortcut.withAlt) return;
+				if (shortcut.key === "Backspace") return;
+			}
+			event.preventDefault();
+			matchingAction.execute();
+		};
+		const handleKeyUp = (event) => {
+			if (event.key.toLowerCase() === "l") releaseLock();
+		};
+		const releaseLock = () => {
+			if (previousLockState.current === null) return;
+			const holdDuration = lockKeyDownTime.current !== null ? Date.now() - lockKeyDownTime.current : Infinity;
+			lockKeyDownTime.current = null;
+			if ((holdDuration < HOLD_THRESHOLD_MS ? !previousLockState.current : previousLockState.current) !== previewStore.getSnapshot().context.isContentLocked) previewStore.send({ type: "toggleLockContent" });
+			previousLockState.current = null;
+		};
+		const handleMessage = (event) => {
+			if (event.data?.type === "holdLockContent") {
+				if (previousLockState.current === null) {
+					lockKeyDownTime.current = Date.now();
+					previousLockState.current = previewStore.getSnapshot().context.isContentLocked;
+					if (!previousLockState.current) previewStore.send({ type: "toggleLockContent" });
+				}
+				return;
+			}
+			if (event.data?.type === "releaseLockContent") {
+				releaseLock();
+				return;
+			}
+			if (event.data?.type === "executeAction") {
+				const { actionId } = event.data;
+				const action = actions.find((a) => a.id === actionId);
+				if (action) action.execute();
+			}
+		};
+		document.addEventListener("keydown", handleKeyDown);
+		document.addEventListener("keyup", handleKeyUp);
+		window.addEventListener("message", handleMessage);
+		return () => {
+			document.removeEventListener("keydown", handleKeyDown);
+			document.removeEventListener("keyup", handleKeyUp);
+			window.removeEventListener("message", handleMessage);
+		};
+	}, [actions]);
+}
+//#endregion
+export { useAdminShortcuts };

package/dist/features/routes/ogRoute.d.ts

@@ -0,0 +1,7 @@
+import { CamoxApp } from '../../core/createApp';
+export declare function createOgHandler(camoxApp: CamoxApp): {
+    GET: ({ request }: {
+        request: Request;
+    }) => Promise<Response>;
+};
+//# sourceMappingURL=ogRoute.d.ts.map

package/dist/features/routes/ogRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogRoute.d.ts","sourceRoot":"","sources":["../../../src/features/routes/ogRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ;uBAErB;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE;EAehD"}

package/dist/features/routes/ogRoute.js

@@ -0,0 +1,19 @@
+//#region src/features/routes/ogRoute.ts
+function createOgHandler(camoxApp) {
+	return { GET: async ({ request }) => {
+		const url = new URL(request.url);
+		const layoutId = url.searchParams.get("layoutId") || "";
+		const title = url.searchParams.get("title") || "";
+		const description = url.searchParams.get("description") || "";
+		const projectName = url.searchParams.get("projectName") || "";
+		const layout = camoxApp.getLayoutById(layoutId);
+		if (!layout?.buildOgImage) return new Response("Not found", { status: 404 });
+		return layout.buildOgImage({
+			title,
+			description,
+			projectName
+		});
+	} };
+}
+//#endregion
+export { createOgHandler };