@powerhousedao/builder-tools 0.2.0

package/dist/document-model-editor/context/schema-context.js

@@ -0,0 +1,116 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createDefaultRules, isDocumentString } from "@graphql-tools/utils";
+import { buildASTSchema, buildSchema, Kind, parse, printSchema, validate, } from "graphql";
+import { createContext, useContext, useEffect, useState } from "react";
+import { hiddenQueryTypeDefDoc, initialSchema, typeDefsDoc, } from "../constants/documents.js";
+/* Required to make the schema "count" as an actual schema */
+const hiddenQueryTypeDefinitions = parse(hiddenQueryTypeDefDoc).definitions;
+/* Scalar definitions from the Powerhouse standard library */
+const standardLibCustomScalarDefinitions = parse(typeDefsDoc).definitions;
+/* These are always included when updating the shared schema, because they do not change */
+const alwaysIncludedDefinitions = [
+    ...hiddenQueryTypeDefinitions,
+    ...standardLibCustomScalarDefinitions,
+];
+/* We use almost all of the standard graphql rules, but not the ExecutableDefinitionsRule because our schemas are not intended to be executed */
+const rules = createDefaultRules().filter((rule) => rule.name !== "ExecutableDefinitionsRule");
+/*
+ Makes one SDL string from all of the definitions in the state and operation schemas
+ Uses try catch to prevent errors from breaking the editor
+*/
+function makeSharedSchemaSdl(existingSchemaSdl, globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl) {
+    try {
+        const existingSchema = buildSchema(existingSchemaSdl);
+        const sdls = [
+            globalStateSchemaSdl,
+            localStateSchemaSdl,
+            operationSchemasSdl,
+        ].filter(Boolean);
+        const asts = sdls
+            .map((sdl) => (sdl ? safeParseSdl(sdl) : null))
+            .filter((ast) => ast !== null);
+        const documentNode = makeSafeDocumentNode(existingSchema, asts);
+        const schemaSdl = printSchema(buildASTSchema(documentNode));
+        return schemaSdl;
+    }
+    catch (error) {
+        console.debug("in make shared schema", error);
+        return existingSchemaSdl;
+    }
+}
+/*
+ Combines all of the definitions in the state and operation schemas into one document node
+ Uses try catch to prevent errors from breaking the editor
+*/
+function makeSafeDocumentNode(schema, asts) {
+    try {
+        const definitions = [...alwaysIncludedDefinitions];
+        for (const ast of asts) {
+            for (const definition of ast.definitions) {
+                const definitionDocumentNode = {
+                    kind: Kind.DOCUMENT,
+                    definitions: [definition],
+                };
+                if (safeValidateAst(schema, definitionDocumentNode)) {
+                    definitions.push(definition);
+                }
+            }
+        }
+        const documentNode = {
+            kind: Kind.DOCUMENT,
+            definitions,
+        };
+        return documentNode;
+    }
+    catch (error) {
+        console.debug("in make safe document node", error);
+        return {
+            kind: Kind.DOCUMENT,
+            definitions: alwaysIncludedDefinitions,
+        };
+    }
+}
+/*
+ Validates an ast against the schema
+ Uses try catch to prevent errors from breaking the editor
+*/
+function safeValidateAst(schema, ast) {
+    try {
+        const errors = validate(schema, ast, rules);
+        return !errors.length;
+    }
+    catch (error) {
+        console.debug("in safe validate", error);
+        return false;
+    }
+}
+/*
+ Parses an SDL string into an ast
+ Uses try catch abd checks if the SDL is a valid document string to prevent errors from breaking the editor
+*/
+function safeParseSdl(sdl) {
+    try {
+        if (!sdl || !isDocumentString(sdl))
+            return null;
+        return parse(sdl);
+    }
+    catch (error) {
+        return null;
+    }
+}
+export const SchemaContext = createContext(printSchema(initialSchema));
+/*
+ Provides the shared schema to the editor
+ We use the sdl string form to make memoization easier
+*/
+export function SchemaContextProvider(props) {
+    const { children, globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl, } = props;
+    const [sharedSchemaSdl, setSharedSchemaSdl] = useState(() => makeSharedSchemaSdl(printSchema(initialSchema), globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl));
+    useEffect(() => {
+        setSharedSchemaSdl((prev) => makeSharedSchemaSdl(prev, globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl));
+    }, [globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl]);
+    return (_jsx(SchemaContext.Provider, { value: sharedSchemaSdl, children: children }));
+}
+export function useSchemaContext() {
+    return useContext(SchemaContext);
+}

package/dist/document-model-editor/document-model-editor.stories.d.ts

@@ -0,0 +1,48 @@
+import { Meta } from "@storybook/react";
+import { DocumentModelEditor } from "./editor.js";
+declare const Empty: import("@storybook/types").StoryAnnotations<import("@storybook/react").ReactRenderer, import("document-model").EditorProps<import("document-model").DocumentModelDocument> & Partial<{
+    isAllowedToCreateDocuments: boolean;
+    isAllowedToEditDocuments: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    onSwitchboardLinkClick: (() => void) | undefined;
+    onExport: () => void;
+    onClose: () => void;
+    onShowRevisionHistory: () => void;
+    simulateBackgroundUpdates?: {
+        backgroundUpdateRate: number;
+        backgroundUpdateActions: ((document: import("document-model").DocumentModelDocument) => import("document-model").DocumentModelAction)[];
+    } | undefined;
+}>>;
+declare const WithData: import("@storybook/types").StoryAnnotations<import("@storybook/react").ReactRenderer, import("document-model").EditorProps<import("document-model").DocumentModelDocument> & Partial<{
+    isAllowedToCreateDocuments: boolean;
+    isAllowedToEditDocuments: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    onSwitchboardLinkClick: (() => void) | undefined;
+    onExport: () => void;
+    onClose: () => void;
+    onShowRevisionHistory: () => void;
+    simulateBackgroundUpdates?: {
+        backgroundUpdateRate: number;
+        backgroundUpdateActions: ((document: import("document-model").DocumentModelDocument) => import("document-model").DocumentModelAction)[];
+    } | undefined;
+}>>;
+declare const WithBackgroundUpdates: import("@storybook/types").StoryAnnotations<import("@storybook/react").ReactRenderer, import("document-model").EditorProps<import("document-model").DocumentModelDocument> & Partial<{
+    isAllowedToCreateDocuments: boolean;
+    isAllowedToEditDocuments: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    onSwitchboardLinkClick: (() => void) | undefined;
+    onExport: () => void;
+    onClose: () => void;
+    onShowRevisionHistory: () => void;
+    simulateBackgroundUpdates?: {
+        backgroundUpdateRate: number;
+        backgroundUpdateActions: ((document: import("document-model").DocumentModelDocument) => import("document-model").DocumentModelAction)[];
+    } | undefined;
+}>>;
+declare const _default: Meta<typeof DocumentModelEditor>;
+export default _default;
+export { Empty, WithBackgroundUpdates, WithData };
+//# sourceMappingURL=document-model-editor.stories.d.ts.map

package/dist/document-model-editor/document-model-editor.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model-editor.stories.d.ts","sourceRoot":"","sources":["../../document-model-editor/document-model-editor.stories.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAMxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAElD,QAAA,MAAmC,KAAK;;;;;;;;;;;;;GAIvC,CAAC;AAEF,QAAA,MAA6B,QAAQ;;;;;;;;;;;;;GAoGpC,CAAC;AAEF,QAAA,MAA6B,qBAAqB;;;;;;;;;;;;;GA+KjD,CAAC;wBAEuD,IAAI,CAC3D,OAAO,mBAAmB,CAC3B;AAFD,wBAEE;AAEF,OAAO,EAAE,KAAK,EAAE,qBAAqB,EAAE,QAAQ,EAAE,CAAC"}

package/dist/document-model-editor/document-model-editor.stories.js

@@ -0,0 +1,252 @@
+import { createDocumentStory } from "#editor-utils/storybook";
+import { documentModelCreateExtendedState, documentModelReducer, } from "document-model";
+import { v7 as uuidv7 } from "uuid";
+import { DocumentModelEditor } from "./editor.js";
+const { meta, CreateDocumentStory: Empty } = createDocumentStory(DocumentModelEditor, documentModelReducer, documentModelCreateExtendedState());
+const { CreateDocumentStory: WithData } = createDocumentStory(DocumentModelEditor, documentModelReducer, documentModelCreateExtendedState({
+    state: {
+        global: {
+            id: "test type",
+            name: "test",
+            extension: ".test.ph",
+            description: "test description",
+            author: {
+                name: "test user",
+                website: "https://test.com",
+            },
+            specifications: [
+                {
+                    version: 1,
+                    changeLog: [],
+                    state: {
+                        global: {
+                            schema: 'type TestState {\n  "Add your global state fields here"\n  _placeholder: String\n  something: Int\n  another: Boolean\n}',
+                            initialValue: '{\n  "_placeholder": "",\n  "something": 0,\n  "another": false\n}',
+                            examples: [],
+                        },
+                        local: {
+                            schema: 'type TestLocalState {\n  "Add your local state fields here"\n  _placeholder: String\n  test: String\n  another: Int\n}',
+                            initialValue: '{\n  "_placeholder": "",\n  "test": "",\n  "another": 0\n}',
+                            examples: [],
+                        },
+                    },
+                    modules: [
+                        {
+                            id: "TuKeTdrcoKwzZe0ZJQCrWLr4pGw=",
+                            name: "test_module",
+                            description: "",
+                            operations: [
+                                {
+                                    id: "NEYEmynbmVnx5ZlESaoVx18pl38=",
+                                    name: "TEST_OPERATION",
+                                    description: "test operation description",
+                                    schema: 'input TestOperationInput {\n  "Add your inputs here"\n  _placeholder: String\n  test: TestInput\n}\n\ninput TestInput {\n  test: String\n}',
+                                    template: "",
+                                    reducer: "",
+                                    errors: [
+                                        {
+                                            id: "FwZyM4KAxRO+GurVuSRxgaENKSk=",
+                                            name: "TestException",
+                                            code: "",
+                                            description: "",
+                                            template: "",
+                                        },
+                                    ],
+                                    examples: [],
+                                    scope: "global",
+                                },
+                            ],
+                        },
+                        {
+                            id: "Uix/waNZU0L0Q6bryt7QFnf3aoA=",
+                            name: "another_test_module",
+                            description: "",
+                            operations: [
+                                {
+                                    id: "iDXCKGVaDPPCyTVxv8vQ2h7SVvw=",
+                                    name: "ANOTHER_TEST_OPERATION",
+                                    description: "another description",
+                                    schema: 'input AnotherTestOperationInput {\n  "Add your inputs here"\n  _placeholder: String\n  test: Int\n}',
+                                    template: "",
+                                    reducer: "",
+                                    errors: [],
+                                    examples: [],
+                                    scope: "global",
+                                },
+                                {
+                                    id: "N2Flem5MW4dnLd0y21si2J0ZA9E=",
+                                    name: "ONE_MORE_OPERATION",
+                                    description: "one more description",
+                                    schema: 'input OneMoreOperationInput {\n  "Add your inputs here"\n  _placeholder: String\n}',
+                                    template: "",
+                                    reducer: "",
+                                    errors: [],
+                                    examples: [],
+                                    scope: "global",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        },
+        local: {},
+    },
+}));
+const { CreateDocumentStory: WithBackgroundUpdates } = createDocumentStory(DocumentModelEditor, documentModelReducer, documentModelCreateExtendedState({
+    state: {
+        global: {
+            id: "test type",
+            name: "test",
+            extension: ".test.ph",
+            description: "test description",
+            author: {
+                name: "test user",
+                website: "https://test.com",
+            },
+            specifications: [
+                {
+                    version: 1,
+                    changeLog: [],
+                    state: {
+                        global: {
+                            schema: 'type TestState {\n  "Add your global state fields here"\n  _placeholder: String\n  something: Int\n  another: Boolean\n}',
+                            initialValue: '{\n  "_placeholder": "",\n  "something": 0,\n  "another": false\n}',
+                            examples: [],
+                        },
+                        local: {
+                            schema: 'type TestLocalState {\n  "Add your local state fields here"\n  _placeholder: String\n  test: String\n  another: Int\n}',
+                            initialValue: '{\n  "_placeholder": "",\n  "test": "",\n  "another": 0\n}',
+                            examples: [],
+                        },
+                    },
+                    modules: [
+                        {
+                            id: "TuKeTdrcoKwzZe0ZJQCrWLr4pGw=",
+                            name: "test_module",
+                            description: "",
+                            operations: [
+                                {
+                                    id: "NEYEmynbmVnx5ZlESaoVx18pl38=",
+                                    name: "TEST_OPERATION",
+                                    description: "test operation description",
+                                    schema: 'input TestOperationInput {\n  "Add your inputs here"\n  _placeholder: String\n  test: TestInput\n}\n\ninput TestInput {\n  test: String\n}',
+                                    template: "",
+                                    reducer: "",
+                                    errors: [
+                                        {
+                                            id: "FwZyM4KAxRO+GurVuSRxgaENKSk=",
+                                            name: "TestException",
+                                            code: "",
+                                            description: "",
+                                            template: "",
+                                        },
+                                    ],
+                                    examples: [],
+                                    scope: "global",
+                                },
+                            ],
+                        },
+                        {
+                            id: "Uix/waNZU0L0Q6bryt7QFnf3aoA=",
+                            name: "another_test_module",
+                            description: "",
+                            operations: [
+                                {
+                                    id: "iDXCKGVaDPPCyTVxv8vQ2h7SVvw=",
+                                    name: "ANOTHER_TEST_OPERATION",
+                                    description: "another description",
+                                    schema: 'input AnotherTestOperationInput {\n  "Add your inputs here"\n  _placeholder: String\n  test: Int\n}',
+                                    template: "",
+                                    reducer: "",
+                                    errors: [],
+                                    examples: [],
+                                    scope: "global",
+                                },
+                                {
+                                    id: "N2Flem5MW4dnLd0y21si2J0ZA9E=",
+                                    name: "ONE_MORE_OPERATION",
+                                    description: "one more description",
+                                    schema: 'input OneMoreOperationInput {\n  "Add your inputs here"\n  _placeholder: String\n}',
+                                    template: "",
+                                    reducer: "",
+                                    errors: [],
+                                    examples: [],
+                                    scope: "global",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        },
+        local: {},
+    },
+}), {
+    simulateBackgroundUpdates: {
+        backgroundUpdateRate: 1000,
+        backgroundUpdateActions: [
+            (document) => {
+                const id = uuidv7().split("-").at(-1);
+                const oldStateSchema = document.state.global.specifications[0].state.global.schema;
+                const newTypeDef = `
+type TestDefinition${id} {
+  test: String
+}`;
+                const newStateSchema = `${oldStateSchema}\n${newTypeDef}`;
+                return {
+                    type: "SET_STATE_SCHEMA",
+                    input: {
+                        schema: newStateSchema,
+                        scope: "global",
+                    },
+                    scope: "global",
+                };
+            },
+            (document) => {
+                const id = uuidv7().split("-").at(-1);
+                const oldStateSchema = document.state.global.specifications[0].state.local.schema;
+                const newTypeDef = `
+type TestLocalDefinition${id} {
+  test: String
+}`;
+                const newStateSchema = `${oldStateSchema}\n${newTypeDef}`;
+                return {
+                    type: "SET_STATE_SCHEMA",
+                    input: {
+                        schema: newStateSchema,
+                        scope: "local",
+                    },
+                    scope: "global",
+                };
+            },
+            (document) => {
+                const moduleIndex = document.state.global.specifications[0].modules.length + 1;
+                return {
+                    type: "ADD_MODULE",
+                    input: {
+                        id: uuidv7(),
+                        name: `test_module_${moduleIndex}`,
+                    },
+                    scope: "global",
+                };
+            },
+            (document) => {
+                const modules = document.state.global.specifications[0].modules;
+                const module = modules[0];
+                const operationIndex = module.operations.length + 1;
+                return {
+                    type: "ADD_OPERATION",
+                    input: {
+                        id: uuidv7(),
+                        name: `test_operation_${operationIndex}`,
+                        moduleId: module.id,
+                    },
+                    scope: "global",
+                };
+            },
+        ],
+    },
+});
+export default { ...meta, title: "Document Model 2" };
+export { Empty, WithBackgroundUpdates, WithData };

package/dist/document-model-editor/editor.d.ts

@@ -0,0 +1,3 @@
+import { DocumentModelDocument, EditorProps } from "document-model";
+export declare function DocumentModelEditor(props: EditorProps<DocumentModelDocument>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=editor.d.ts.map

package/dist/document-model-editor/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../../document-model-editor/editor.tsx"],"names":[],"mappings":"AAAA,OAAO,EAOL,qBAAqB,EACrB,WAAW,EAeZ,MAAM,gBAAgB,CAAC;AAcxB,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,CAAC,qBAAqB,CAAC,2CAqX5E"}

package/dist/document-model-editor/editor.js

@@ -0,0 +1,186 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { addModule, addOperation, addOperationError, deleteModule, deleteOperation, deleteOperationError, hashKey, setAuthorName, setAuthorWebsite, setInitialState, setModelDescription, setModelExtension, setModelId, setModelName, setModuleName, setOperationDescription, setOperationErrorName, setOperationName, setOperationSchema, setStateSchema, } from "document-model";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { Divider } from "./components/divider.js";
+import { ModelMetadata } from "./components/model-metadata-form.js";
+import { Modules } from "./components/modules.js";
+import { StateSchemas } from "./components/state-schemas.js";
+import { SchemaContextProvider } from "./context/schema-context.js";
+import { compareStringsWithoutWhitespace, initializeModelSchema, makeOperationInitialDoc, } from "./utils/helpers.js";
+export function DocumentModelEditor(props) {
+    const { document, documentNodeName, dispatch } = props;
+    const { name: modelName, id: documentType, extension, description, author: { name: authorName, website: authorWebsite }, } = useMemo(() => document.state.global, [document.state.global]);
+    const { state: { global: { schema: globalStateSchema, initialValue: globalStateInitialValue, }, local: { schema: localStateSchema, initialValue: localStateInitialValue }, }, modules, } = useMemo(() => document.state.global.specifications[0], [document.state.global.specifications[0]]);
+    const operations = useMemo(() => modules.flatMap((module) => module.operations), [modules]);
+    const shouldSetInitialName = useRef(!modelName && !!documentNodeName && operations.length === 0);
+    useEffect(() => {
+        if (!shouldSetInitialName.current || !documentNodeName)
+            return;
+        dispatch(setModelName({ name: documentNodeName }));
+        // Initialize schema if it's the first time setting the name
+        initializeModelSchema({
+            modelName: documentNodeName,
+            setStateSchema: (schema, scope) => {
+                dispatch(setStateSchema({ schema, scope }));
+            },
+        });
+        shouldSetInitialName.current = false;
+    }, [documentNodeName]);
+    const operationSchemasSdl = useMemo(() => operations.flatMap((operation) => operation.schema ?? []).join("\n"), [operations]);
+    const handleSetModelId = useCallback((id) => {
+        if (compareStringsWithoutWhitespace(id, documentType))
+            return;
+        dispatch(setModelId({ id }));
+    }, [documentType]);
+    const handleSetModelDescription = useCallback((newDescription) => {
+        if (compareStringsWithoutWhitespace(newDescription, description))
+            return;
+        dispatch(setModelDescription({ description: newDescription }));
+    }, [description]);
+    const handleSetModelExtension = useCallback((newExtension) => {
+        if (compareStringsWithoutWhitespace(newExtension, extension))
+            return;
+        dispatch(setModelExtension({ extension: newExtension }));
+    }, [extension]);
+    const handleSetModelName = useCallback((newName) => {
+        if (compareStringsWithoutWhitespace(newName, modelName))
+            return;
+        dispatch(setModelName({ name: newName }));
+    }, [modelName]);
+    const handleSetAuthorName = useCallback((newAuthorName) => {
+        if (compareStringsWithoutWhitespace(newAuthorName, authorName))
+            return;
+        dispatch(setAuthorName({ authorName: newAuthorName }));
+    }, [authorName]);
+    const handleSetAuthorWebsite = useCallback((newAuthorWebsite) => {
+        if (compareStringsWithoutWhitespace(newAuthorWebsite, authorWebsite ?? ""))
+            return;
+        dispatch(setAuthorWebsite({ authorWebsite: newAuthorWebsite }));
+    }, [authorWebsite]);
+    const handleSetStateSchema = useCallback((newSchema, scope) => {
+        const oldSchema = scope === "global" ? globalStateSchema : localStateSchema;
+        if (compareStringsWithoutWhitespace(newSchema, oldSchema))
+            return;
+        dispatch(setStateSchema({ schema: newSchema, scope }));
+    }, [globalStateSchema, localStateSchema]);
+    const handleSetInitialState = useCallback((newInitialValue, scope) => {
+        const oldInitialValue = scope === "global" ? globalStateInitialValue : localStateInitialValue;
+        if (compareStringsWithoutWhitespace(newInitialValue, oldInitialValue))
+            return;
+        dispatch(setInitialState({ initialValue: newInitialValue, scope }));
+    }, [globalStateInitialValue, localStateInitialValue]);
+    const handleAddModule = useCallback((name) => {
+        return new Promise((resolve) => {
+            try {
+                if (modules.some((module) => compareStringsWithoutWhitespace(module.name, name))) {
+                    resolve(undefined);
+                    return;
+                }
+                const id = hashKey();
+                dispatch(addModule({ id, name }));
+                resolve(id);
+            }
+            catch (error) {
+                console.error("Failed to add module:", error);
+                resolve(undefined);
+            }
+        });
+    }, [modules]);
+    const handleSetModuleName = useCallback((id, name) => {
+        if (modules.some((module) => compareStringsWithoutWhitespace(module.name, name)))
+            return;
+        dispatch(setModuleName({ id, name }));
+    }, [modules]);
+    const handleDeleteModule = useCallback((id) => dispatch(deleteModule({ id })), []);
+    const handleAddOperation = useCallback((moduleId, name) => {
+        return new Promise((resolve) => {
+            try {
+                const moduleOperationNames = modules
+                    .find((module) => module.id === moduleId)
+                    ?.operations.map((operation) => operation.name)
+                    .filter(Boolean) ?? [];
+                if (moduleOperationNames.some((opName) => compareStringsWithoutWhitespace(opName, name))) {
+                    resolve(undefined);
+                    return;
+                }
+                const id = hashKey();
+                dispatch(addOperation({ id, moduleId, name }));
+                resolve(id);
+            }
+            catch (error) {
+                console.error("Failed to add operation:", error);
+                resolve(undefined);
+            }
+        });
+    }, [modules]);
+    const handleSetOperationName = useCallback((id, name) => {
+        const operationModule = modules.find((module) => module.operations.some((operation) => operation.id === id));
+        const operationNames = operationModule?.operations
+            .map((operation) => operation.name)
+            .filter(Boolean) ?? [];
+        if (operationNames.some((opName) => compareStringsWithoutWhitespace(opName, name)))
+            return;
+        dispatch(setOperationName({ id, name }));
+    }, [modules]);
+    const handleSetOperationSchema = useCallback((id, newSchema) => {
+        const operation = operations.find((operation) => operation.id === id);
+        if (operation?.schema &&
+            compareStringsWithoutWhitespace(newSchema, operation.schema))
+            return;
+        dispatch(setOperationSchema({ id, schema: newSchema }));
+    }, [operations]);
+    const handleSetOperationDescription = useCallback((id, newDescription) => {
+        const operationDescription = operations.find((operation) => operation.id === id)?.description ?? "";
+        if (compareStringsWithoutWhitespace(operationDescription, newDescription))
+            return;
+        dispatch(setOperationDescription({ id, description: newDescription }));
+    }, [operations]);
+    const handleDeleteOperation = useCallback((id) => dispatch(deleteOperation({ id })), []);
+    const handleAddOperationError = useCallback((operationId, errorName) => {
+        return new Promise((resolve) => {
+            try {
+                const operation = operations.find((operation) => operation.id === operationId);
+                const operationErrorNames = operation?.errors.map((error) => error.name).filter(Boolean) ?? [];
+                if (operationErrorNames.some((name) => compareStringsWithoutWhitespace(name, errorName))) {
+                    resolve(undefined);
+                    return;
+                }
+                const id = hashKey();
+                dispatch(addOperationError({ id, operationId, errorName }));
+                resolve(id);
+            }
+            catch (error) {
+                console.error("Failed to add operation error:", error);
+                resolve(undefined);
+            }
+        });
+    }, [operations]);
+    const handleDeleteOperationError = useCallback((id) => dispatch(deleteOperationError({ id })), []);
+    const handleSetOperationErrorName = useCallback((operationId, errorId, errorName) => {
+        const operation = operations.find((operation) => operation.id === operationId);
+        const operationErrorNames = operation?.errors.map((error) => error.name).filter(Boolean) ?? [];
+        if (operationErrorNames.some((name) => compareStringsWithoutWhitespace(name, errorName)))
+            return;
+        dispatch(setOperationErrorName({ id: errorId, errorName }));
+    }, [operations]);
+    const addOperationAndInitialSchema = useCallback(async (moduleId, name) => {
+        try {
+            const id = await handleAddOperation(moduleId, name);
+            if (!id)
+                return undefined;
+            try {
+                handleSetOperationSchema(id, makeOperationInitialDoc(name));
+                return id;
+            }
+            catch (error) {
+                console.error("Failed to update operation schema:", error);
+                return undefined;
+            }
+        }
+        catch (error) {
+            console.error("Failed to add operation and schema:", error);
+            return undefined;
+        }
+    }, [handleAddOperation, handleSetOperationSchema]);
+    return (_jsx("main", { className: "min-h-dvh bg-gray-50", children: _jsx(SchemaContextProvider, { globalStateSchemaSdl: globalStateSchema, localStateSchemaSdl: localStateSchema, operationSchemasSdl: operationSchemasSdl, children: _jsxs("div", { className: "mx-auto max-w-6xl px-4 pt-8", children: [_jsx(ModelMetadata, { name: modelName, documentType: documentType, extension: extension, description: description, authorName: authorName, authorWebsite: authorWebsite ?? "", globalStateSchema: globalStateSchema, localStateSchema: localStateSchema, setModelId: handleSetModelId, setModelDescription: handleSetModelDescription, setModelExtension: handleSetModelExtension, setModelName: handleSetModelName, setAuthorName: handleSetAuthorName, setAuthorWebsite: handleSetAuthorWebsite, setStateSchema: handleSetStateSchema }), _jsx(Divider, {}), _jsxs("div", { children: [_jsx(StateSchemas, { modelName: modelName, globalStateSchema: globalStateSchema, globalStateInitialValue: globalStateInitialValue, localStateSchema: localStateSchema, localStateInitialValue: localStateInitialValue, setStateSchema: handleSetStateSchema, setInitialState: handleSetInitialState }), _jsx(Divider, {}), _jsx("h3", { className: "mb-6 text-lg", children: "Global Operations" }), _jsx(Modules, { modules: modules, allOperations: operations, addModule: handleAddModule, updateModuleName: handleSetModuleName, deleteModule: handleDeleteModule, updateOperationName: handleSetOperationName, updateOperationSchema: handleSetOperationSchema, setOperationDescription: handleSetOperationDescription, deleteOperation: handleDeleteOperation, addOperationError: handleAddOperationError, deleteOperationError: handleDeleteOperationError, setOperationErrorName: handleSetOperationErrorName, addOperationAndInitialSchema: addOperationAndInitialSchema })] })] }) }) }));
+}

package/dist/document-model-editor/hooks/useFormField.d.ts

@@ -0,0 +1,13 @@
+export declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import("react-hook-form").FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+//# sourceMappingURL=useFormField.d.ts.map

package/dist/document-model-editor/hooks/useFormField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormField.d.ts","sourceRoot":"","sources":["../../../document-model-editor/hooks/useFormField.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;;;;;;;CAqBxB,CAAC"}

package/dist/document-model-editor/hooks/useFormField.js

@@ -0,0 +1,21 @@
+import React from "react";
+import { useFormContext } from "react-hook-form";
+import { FormFieldContext, FormItemContext } from "../context/form-context.js";
+export const useFormField = () => {
+    const fieldContext = React.useContext(FormFieldContext);
+    const itemContext = React.useContext(FormItemContext);
+    const { getFieldState, formState } = useFormContext();
+    const fieldState = getFieldState(fieldContext.name, formState);
+    if (!fieldContext) {
+        throw new Error("useFormField should be used within <FormField>");
+    }
+    const { id } = itemContext;
+    return {
+        id,
+        name: fieldContext.name,
+        formItemId: `${id}-form-item`,
+        formDescriptionId: `${id}-form-item-description`,
+        formMessageId: `${id}-form-item-message`,
+        ...fieldState,
+    };
+};

package/dist/document-model-editor/index.d.ts

@@ -0,0 +1,3 @@
+export { DocumentModelEditor } from "./editor.js";
+export { documentModelEditorModule } from "./module.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/document-model-editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../document-model-editor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC"}