@powerhousedao/builder-tools 0.2.0

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

@@ -0,0 +1,2 @@
+export { DocumentModelEditor } from "./editor.js";
+export { documentModelEditorModule } from "./module.js";

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

@@ -0,0 +1,4 @@
+import type { DocumentModelDocument } from "document-model";
+import { EditorModule } from "document-model";
+export declare const documentModelEditorModule: EditorModule<DocumentModelDocument>;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../document-model-editor/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,qBAAqB,CAQzE,CAAC"}

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

@@ -0,0 +1,10 @@
+import { DocumentModelEditor } from "./editor.js";
+export const documentModelEditorModule = {
+    Component: DocumentModelEditor,
+    documentTypes: ["powerhouse/document-model"],
+    config: {
+        id: "document-model-editor-v2",
+        disableExternalControls: true,
+        documentToolbarEnabled: true,
+    },
+};

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

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare function containsSpaces(s: string): boolean;
+export declare function replaceSpaces(s: string): string;
+type SchemaOptions = {
+    required?: boolean;
+    allowEmpty?: boolean;
+    unique?: string[];
+};
+export declare function createNameSchema(options?: SchemaOptions): z.ZodString | z.ZodEffects<z.ZodString, string, string> | z.ZodOptional<z.ZodString> | z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+export declare function createConstantCaseSchema(options?: SchemaOptions): z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>, string | undefined, string | undefined> | z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>, string | undefined, string | undefined>, string | undefined, string | undefined> | z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string | undefined, string>, string | undefined, string> | z.ZodEffects<z.ZodEffects<z.ZodString, string | undefined, string>, string | undefined, string>;
+export declare function createLowercaseSnakeCaseSchema(options?: SchemaOptions): z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>, string | undefined, string | undefined> | z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>, string | undefined, string | undefined>, string | undefined, string | undefined> | z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string | undefined, string>, string | undefined, string> | z.ZodEffects<z.ZodEffects<z.ZodString, string | undefined, string>, string | undefined, string>;
+export declare function toLowercaseSnakeCase(value: string, options?: SchemaOptions): LowercaseSnakeCase;
+export declare function toConstantCase(value: string, options?: SchemaOptions): ConstantCase;
+export type SnakeCase = `${string}_${string}`;
+export type LowercaseSnakeCase = Lowercase<SnakeCase>;
+export type ConstantCase = Uppercase<SnakeCase>;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export declare const AuthorSchema: z.ZodDefault<z.ZodObject<{
+    name: z.ZodString | z.ZodEffects<z.ZodString, string, string> | z.ZodOptional<z.ZodString> | z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    website: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>>;
+}, "strip", z.ZodTypeAny, {
+    website: string;
+    name?: string | undefined;
+}, {
+    name?: string | undefined;
+    website?: string | undefined;
+}>>;
+export {};
+//# sourceMappingURL=inputs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inputs.d.ts","sourceRoot":"","sources":["../../../document-model-editor/schemas/inputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,WAEvC;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,UAEtC;AAED,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,aAAkB,2KAkC3D;AAED,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,aAAkB,2iBAMnE;AAED,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,aAAkB,2iBAMzE;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,aAAkB,GAItB,kBAAkB,CACxB;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAGlE,YAAY,CAClB;AAED,MAAM,MAAM,SAAS,GAAG,GAAG,MAAM,IAAI,MAAM,EAAE,CAAC;AAC9C,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;AAChD,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;KACvB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,GAAG,EAAE,CAAC;AAEP,eAAO,MAAM,YAAY;;;;;;;;;GAWrB,CAAC"}

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

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import validator from "validator";
+import { snakeCase, constantCase } from "change-case";
+const whitespaceRegex = /\s+/g;
+export function containsSpaces(s) {
+    return whitespaceRegex.test(s);
+}
+export function replaceSpaces(s) {
+    return s.replace(whitespaceRegex, "_");
+}
+export function createNameSchema(options = {}) {
+    const { required = false, allowEmpty = false, unique = [] } = options;
+    const baseSchema = allowEmpty ? z.string() : z.string().min(1);
+    const uniqueRefinement = baseSchema.refine((value) => {
+        if (!value && allowEmpty)
+            return true;
+        return !unique
+            .map((n) => n.toLowerCase())
+            .includes(value.replace(/^\s+|\s+$/g, "_").toLowerCase());
+    }, { message: "Item with this name already exists" });
+    if (!required) {
+        return unique.length > 0
+            ? z
+                .string()
+                .optional()
+                .refine((value) => {
+                if (value === undefined)
+                    return true;
+                if (!value && allowEmpty)
+                    return true;
+                return !unique
+                    .map((n) => n.toLowerCase())
+                    .includes(value.replace(/^\s+|\s+$/g, "_").toLowerCase());
+            }, { message: "Item with this name already exists" })
+            : z.string().optional();
+    }
+    return unique.length > 0 ? uniqueRefinement : baseSchema;
+}
+export function createConstantCaseSchema(options = {}) {
+    return createNameSchema(options)
+        .transform((value) => (value ? value.toUpperCase() : value))
+        .refine((value) => !value || validator.isUppercase(value), {
+        message: "Must be uppercase",
+    });
+}
+export function createLowercaseSnakeCaseSchema(options = {}) {
+    return createNameSchema(options)
+        .transform((value) => (value ? value.toLowerCase() : value))
+        .refine((value) => !value || validator.isLowercase(value), {
+        message: "Must be lowercase",
+    });
+}
+export function toLowercaseSnakeCase(value, options = {}) {
+    return createLowercaseSnakeCaseSchema(options).parse(snakeCase(value));
+}
+export function toConstantCase(value, options = {}) {
+    return createConstantCaseSchema(options).parse(constantCase(value));
+}
+export const AuthorSchema = z
+    .object({
+    name: createNameSchema({ allowEmpty: true }),
+    website: z
+        .union([z.string().url(), z.literal("")])
+        .optional()
+        .default(""),
+})
+    .default({
+    name: "",
+    website: "",
+});

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

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const EmptyStringSchema: z.ZodDefault<z.ZodString>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../document-model-editor/schemas/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB,2BAAyB,CAAC"}

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const EmptyStringSchema = z.string().default("");

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

@@ -0,0 +1,27 @@
+import { OperationScope } from "document-model";
+export type Scope = OperationScope;
+export type DocumentActionHandlers = {
+    addModule: (name: string) => Promise<string | undefined>;
+    addOperation: (moduleId: string, name: string) => Promise<string | undefined>;
+    addOperationAndInitialSchema: (moduleId: string, name: string) => Promise<string | undefined>;
+    addOperationError: (operationId: string, errorName: string) => Promise<string | undefined>;
+    setModelId: (id: string) => void;
+    setModelExtension: (extension: string) => void;
+    setModelName: (name: string) => void;
+    setAuthorName: (authorName: string) => void;
+    setAuthorWebsite: (authorWebsite: string) => void;
+    setStateSchema: (schema: string, scope: Scope) => void;
+    setInitialState: (initialValue: string, scope: Scope) => void;
+    setModelDescription: (description: string) => void;
+    updateModuleName: (id: string, name: string) => void;
+    updateModuleDescription: (id: string, description: string) => void;
+    deleteModule: (id: string) => void;
+    updateOperationName: (id: string, name: string) => void;
+    updateOperationSchema: (id: string, schema: string) => void;
+    updateOperationScope: (id: string, scope: Scope) => void;
+    setOperationDescription: (id: string, description: string) => void;
+    deleteOperation: (id: string) => void;
+    deleteOperationError: (id: string) => void;
+    setOperationErrorName: (operationId: string, errorId: string, errorName: string) => void;
+};
+//# sourceMappingURL=documents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../../document-model-editor/types/documents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD,MAAM,MAAM,KAAK,GAAG,cAAc,CAAC;AAEnC,MAAM,MAAM,sBAAsB,GAAG;IAEnC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACzD,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC9E,4BAA4B,EAAE,CAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,KACT,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACjC,iBAAiB,EAAE,CACjB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,KACd,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAGjC,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,gBAAgB,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI,CAAC;IAClD,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACvD,eAAe,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC9D,mBAAmB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACnD,gBAAgB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrD,uBAAuB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACnE,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,mBAAmB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxD,qBAAqB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5D,oBAAoB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACzD,uBAAuB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACnE,eAAe,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,oBAAoB,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,qBAAqB,EAAE,CACrB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,KACd,IAAI,CAAC;CACX,CAAC"}

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

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

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

@@ -0,0 +1,39 @@
+import { Author, DocumentModelDocument } from "document-model";
+import { Scope } from "../types/documents.js";
+export declare function makeStateObject(modelName: string, scope: Scope): string;
+export declare function makeEmptyInputObject(name: string): string;
+export declare function makeOperationInputName(operationName: string): string;
+export declare function makeStateObjectName(modelName: string, scope: string): string;
+export declare function makeOperationInitialDoc(name: string): string;
+export declare function makeInitialSchemaDoc(modelName: string, scope: Scope): string;
+export declare function makeSchemaStringFromDocs(docs: Record<string, string>): string;
+export declare function getDocumentMetadata(document: DocumentModelDocument): {
+    name: string;
+    documentType: string;
+    description: string;
+    extension: string;
+    author: Author;
+};
+export declare function getDifferences<T extends object>(obj1: T | undefined | null, obj2: Partial<T> | undefined | null): Partial<T>;
+export declare function makeMinimalObjectFromSDL(schemaSdl: string, sdl: string, existingValue?: any): string;
+export declare function compareStringsWithoutWhitespace(str1: string | null | undefined, str2: string | null | undefined): boolean;
+export declare function renameSchemaType(sdl: string, oldName: string, newName: string, scope: Scope): string;
+export declare function initializeModelSchema(params: {
+    modelName: string;
+    setStateSchema: (schema: string, scope: Scope) => void;
+}): void;
+export declare function updateModelSchemaNames(params: {
+    oldName: string;
+    newName: string;
+    globalStateSchema: string;
+    localStateSchema: string;
+    setStateSchema: (schema: string, scope: Scope) => void;
+}): void;
+export declare function handleModelNameChange(params: {
+    oldName: string;
+    newName: string;
+    globalStateSchema: string;
+    localStateSchema: string;
+    setStateSchema: (schema: string, scope: Scope) => void;
+}): void;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../document-model-editor/utils/helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAmB/D,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE9C,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,UA0B9D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,UAyBhD;AAED,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,MAAM,UAE3D;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,UAEnE;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,UAInD;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,UAGnE;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,UAEpE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,qBAAqB;;;;;;EAalE;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC7C,IAAI,EAAE,CAAC,GAAG,SAAS,GAAG,IAAI,EAC1B,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,GAClC,OAAO,CAAC,CAAC,CAAC,CAmDZ;AAoGD,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,aAAa,CAAC,EAAE,GAAG,UAuCpB;AAMD,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC/B,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,WAUhC;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,GACX,MAAM,CAsBR;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACxD,QAIA;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACxD,QA0BA;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACxD,QAWA"}

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

@@ -0,0 +1,293 @@
+import * as customScalars from "@powerhousedao/scalars";
+import { pascalCase } from "change-case";
+import { buildASTSchema, extendSchema, getNullableType, GraphQLScalarType, isEnumType, isListType, isObjectType, isScalarType, Kind, parse, print, visit, } from "graphql";
+export function makeStateObject(modelName, scope) {
+    const name = makeStateObjectName(modelName, scope);
+    const inputNode = {
+        kind: Kind.OBJECT_TYPE_DEFINITION,
+        name: {
+            kind: Kind.NAME,
+            value: name,
+        },
+        fields: [
+            {
+                description: {
+                    kind: Kind.STRING,
+                    value: `Add your ${scope} state fields here`,
+                    block: false,
+                },
+                kind: Kind.FIELD_DEFINITION,
+                name: { kind: Kind.NAME, value: "_placeholder" },
+                type: {
+                    kind: Kind.NAMED_TYPE,
+                    name: { kind: Kind.NAME, value: "String" },
+                },
+            },
+        ],
+    };
+    return print(inputNode);
+}
+export function makeEmptyInputObject(name) {
+    const inputNode = {
+        kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        name: {
+            kind: Kind.NAME,
+            value: name,
+        },
+        fields: [
+            {
+                description: {
+                    kind: Kind.STRING,
+                    value: "Add your inputs here",
+                    block: false,
+                },
+                kind: Kind.INPUT_VALUE_DEFINITION,
+                name: { kind: Kind.NAME, value: "_placeholder" },
+                type: {
+                    kind: Kind.NAMED_TYPE,
+                    name: { kind: Kind.NAME, value: "String" },
+                },
+            },
+        ],
+    };
+    return print(inputNode);
+}
+export function makeOperationInputName(operationName) {
+    return `${pascalCase(operationName)}Input`;
+}
+export function makeStateObjectName(modelName, scope) {
+    return `${pascalCase(modelName)}${scope === "local" ? "Local" : ""}State`;
+}
+export function makeOperationInitialDoc(name) {
+    const inputName = makeOperationInputName(name);
+    const inputObject = makeEmptyInputObject(inputName);
+    return inputObject;
+}
+export function makeInitialSchemaDoc(modelName, scope) {
+    const stateObject = makeStateObject(modelName, scope);
+    return stateObject;
+}
+export function makeSchemaStringFromDocs(docs) {
+    return Object.values(docs).join("\n");
+}
+export function getDocumentMetadata(document) {
+    const globalState = document.state.global;
+    const author = {
+        name: globalState.author.name,
+        website: globalState.author.website,
+    };
+    return {
+        name: globalState.name,
+        documentType: globalState.id,
+        description: globalState.description,
+        extension: globalState.extension,
+        author,
+    };
+}
+export function getDifferences(obj1, obj2) {
+    if (!obj1 || !obj2)
+        return {};
+    const differences = {};
+    function isObject(value) {
+        return !!value && typeof value === "object" && !Array.isArray(value);
+    }
+    const compare = (value1, value2) => {
+        if (isObject(value1) && isObject(value2)) {
+            // Convert both objects to JSON strings to compare them as a whole.
+            const keys1 = Object.keys(value1).sort();
+            const keys2 = Object.keys(value2).sort();
+            if (JSON.stringify(keys1) !== JSON.stringify(keys2) ||
+                keys1.some((key) => compare(value1[key], value2[key]))) {
+                return true; // Any difference in object structure or value means they're different.
+            }
+            return false;
+        }
+        else if (Array.isArray(value1) && Array.isArray(value2)) {
+            // For arrays, compare their serialized forms.
+            return JSON.stringify(value1) !== JSON.stringify(value2);
+        }
+        else {
+            // For primitives, compare directly.
+            return value1 !== value2;
+        }
+    };
+    for (const key of new Set([...Object.keys(obj1), ...Object.keys(obj2)])) {
+        if (compare(obj1[key], obj2[key])) {
+            differences[key] =
+                obj2[key];
+        }
+    }
+    return Object.entries(differences).reduce((acc, [key, value]) => {
+        if (value !== undefined) {
+            // @ts-expect-error generic cannot be inferred
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+function isValidScalarValue(typeName, value) {
+    if (typeName in customScalars) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const scalar = customScalars[typeName];
+        if (scalar instanceof GraphQLScalarType) {
+            return scalar.parseValue(value) !== undefined;
+        }
+    }
+    switch (typeName) {
+        case "Int":
+            return Number.isInteger(value);
+        case "Float":
+            return typeof value === "number";
+        case "Boolean":
+            return typeof value === "boolean";
+        case "DateTime":
+            return typeof value === "string" && !isNaN(Date.parse(value));
+        case "ID":
+        case "String":
+        default:
+            return typeof value === "string";
+    }
+}
+function getMinimalValue(type, schema, existingValue) {
+    const nullableType = getNullableType(type);
+    if (isScalarType(nullableType)) {
+        const typeName = nullableType.name;
+        if (existingValue !== undefined &&
+            isValidScalarValue(typeName, existingValue)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return existingValue;
+        }
+        switch (typeName) {
+            case "Int":
+            case "Float":
+                return 0;
+            case "Boolean":
+                return false;
+            case "DateTime":
+                return new Date().toISOString();
+            case "ID":
+            case "String":
+            default:
+                return ""; // Return empty string for custom scalars and String/ID types
+        }
+    }
+    if (isEnumType(nullableType)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        const enumValues = nullableType.getValues().map((v) => v.value);
+        if (existingValue !== undefined && enumValues.includes(existingValue)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return existingValue;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return enumValues[0] || null;
+    }
+    if (isListType(nullableType)) {
+        if (existingValue !== undefined && Array.isArray(existingValue)) {
+            // Optionally, validate each element in the array
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return existingValue;
+        }
+        return [];
+    }
+    if (isObjectType(nullableType)) {
+        const result = {};
+        const fields = nullableType.getFields();
+        const _existingValue = existingValue;
+        for (const fieldName in fields) {
+            const field = fields[fieldName];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const existingFieldValue = _existingValue
+                ? _existingValue[fieldName]
+                : undefined;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            result[fieldName] = getMinimalValue(field.type, schema, existingFieldValue);
+        }
+        return result;
+    }
+    // Handle other types like InterfaceType, UnionType as needed
+    return null;
+}
+export function makeMinimalObjectFromSDL(schemaSdl, sdl, existingValue) {
+    const schema = buildASTSchema(parse(schemaSdl));
+    const typeAST = parse(sdl);
+    // Extract the type names from the SDL
+    const typeNames = [];
+    typeAST.definitions.forEach((def) => {
+        if (def.kind === Kind.OBJECT_TYPE_DEFINITION ||
+            def.kind === Kind.OBJECT_TYPE_EXTENSION) {
+            typeNames.push(def.name.value);
+        }
+    });
+    if (typeNames.length === 0) {
+        throw new Error("No object type definition found in SDL.");
+    }
+    // Assuming there's only one type definition in the SDL
+    const typeName = typeNames[0];
+    let type = schema.getType(typeName);
+    let effectiveSchema = schema;
+    if (!type || !isObjectType(type)) {
+        // Type doesn't exist in the schema, extend the schema
+        effectiveSchema = extendSchema(schema, typeAST);
+        type = effectiveSchema.getType(typeName);
+    }
+    if (!type || !isObjectType(type)) {
+        throw new Error(`Type "${typeName}" is not a valid ObjectType.`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const minimalObject = getMinimalValue(type, effectiveSchema, existingValue);
+    return JSON.stringify(minimalObject, null, 2);
+}
+function removeWhitespace(str) {
+    return str.replace(/\s+|\\n|\\t/g, "").toLowerCase();
+}
+export function compareStringsWithoutWhitespace(str1, str2) {
+    if (str1 === null ||
+        str2 === null ||
+        str1 === undefined ||
+        str2 === undefined)
+        return false;
+    return removeWhitespace(str1) === removeWhitespace(str2);
+}
+export function renameSchemaType(sdl, oldName, newName, scope) {
+    const typeSuffix = scope === "global" ? "State" : "LocalState";
+    const oldTypeName = `${pascalCase(oldName)}${typeSuffix}`;
+    const newTypeName = `${pascalCase(newName)}${typeSuffix}`;
+    const ast = parse(sdl);
+    const updatedAst = visit(ast, {
+        ObjectTypeDefinition: (node) => {
+            if (node.name.value === oldTypeName) {
+                return {
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                };
+            }
+        },
+    });
+    return print(updatedAst);
+}
+export function initializeModelSchema(params) {
+    const { modelName, setStateSchema } = params;
+    const initialSchemaDoc = makeInitialSchemaDoc(modelName, "global");
+    setStateSchema(initialSchemaDoc, "global");
+}
+export function updateModelSchemaNames(params) {
+    const { oldName, newName, globalStateSchema, localStateSchema, setStateSchema, } = params;
+    const newSchema = renameSchemaType(globalStateSchema, oldName, newName, "global");
+    setStateSchema(newSchema, "global");
+    if (localStateSchema) {
+        const newLocalStateSchema = renameSchemaType(localStateSchema, oldName, newName, "local");
+        setStateSchema(newLocalStateSchema, "local");
+    }
+}
+export function handleModelNameChange(params) {
+    const { oldName, newName, globalStateSchema, setStateSchema } = params;
+    const hasExistingSchema = !!globalStateSchema;
+    if (!hasExistingSchema) {
+        initializeModelSchema({ modelName: newName, setStateSchema });
+        return;
+    }
+    updateModelSchemaNames(params);
+}

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

@@ -0,0 +1,7 @@
+import { Diagnostic } from "@codemirror/lint";
+import { Kind } from "graphql";
+export declare function ensureDocumentContainsNodeWithNameAndType(doc: string, nodeName: string, nodeType: keyof typeof Kind): boolean;
+export declare function createNodeTypeAndNameDiagnostic(doc: string, errorMessage: string): Diagnostic | undefined;
+export declare function ensureValidStateSchemaName(doc: string, modelName: string, scope: string): Diagnostic[];
+export declare function ensureValidOperationSchemaInputName(doc: string | undefined, operationName: string): Diagnostic[];
+//# sourceMappingURL=linting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linting.d.ts","sourceRoot":"","sources":["../../../document-model-editor/utils/linting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAS,IAAI,EAAE,MAAM,SAAS,CAAC;AAEtC,wBAAgB,yCAAyC,CACvD,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,OAAO,IAAI,GAC1B,OAAO,CAUT;AAED,wBAAgB,+BAA+B,CAC7C,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,GACnB,UAAU,GAAG,SAAS,CAcxB;AAED,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,gBAoBd;AAED,wBAAgB,mCAAmC,CACjD,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,aAAa,EAAE,MAAM,gBAqBtB"}

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

@@ -0,0 +1,47 @@
+import { isDocumentString } from "@graphql-tools/utils";
+import { pascalCase, sentenceCase } from "change-case";
+import { parse, Kind } from "graphql";
+export function ensureDocumentContainsNodeWithNameAndType(doc, nodeName, nodeType) {
+    if (!doc || !isDocumentString(doc))
+        return true;
+    const parsedDoc = parse(doc);
+    return parsedDoc.definitions.some((def) => {
+        const hasMatchingType = def.kind === Kind[nodeType];
+        return hasMatchingType && "name" in def && def.name?.value === nodeName;
+    });
+}
+export function createNodeTypeAndNameDiagnostic(doc, errorMessage) {
+    if (!doc || !isDocumentString(doc))
+        return;
+    const parsedDoc = parse(doc);
+    const firstNode = parsedDoc.definitions[0];
+    const nameNode = "name" in firstNode ? firstNode.name : null;
+    return {
+        from: nameNode?.loc?.start ?? firstNode.loc?.start ?? 0,
+        to: nameNode?.loc?.end ?? firstNode.loc?.end ?? 0,
+        severity: "error",
+        message: errorMessage,
+    };
+}
+export function ensureValidStateSchemaName(doc, modelName, scope) {
+    if (!doc || !isDocumentString(doc))
+        return [];
+    const requiredTypeName = `${pascalCase(modelName)}${scope === "local" ? "Local" : ""}State`;
+    if (!ensureDocumentContainsNodeWithNameAndType(doc, requiredTypeName, "OBJECT_TYPE_DEFINITION")) {
+        return [
+            createNodeTypeAndNameDiagnostic(doc, `${sentenceCase(scope)} state schema must be named ${requiredTypeName}`),
+        ].filter((d) => d !== undefined);
+    }
+    return [];
+}
+export function ensureValidOperationSchemaInputName(doc, operationName) {
+    if (!doc || !isDocumentString(doc))
+        return [];
+    const requiredTypeName = `${pascalCase(operationName)}Input`;
+    if (!ensureDocumentContainsNodeWithNameAndType(doc, requiredTypeName, "INPUT_OBJECT_TYPE_DEFINITION")) {
+        return [
+            createNodeTypeAndNameDiagnostic(doc, `Operation schema must contain an input type named ${requiredTypeName}`),
+        ].filter((d) => d !== undefined);
+    }
+    return [];
+}

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

@@ -0,0 +1,3 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=style.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"style.d.ts","sourceRoot":"","sources":["../../../document-model-editor/utils/style.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAC;AAE7C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

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

@@ -0,0 +1,5 @@
+import { twMerge } from "tailwind-merge";
+import { clsx } from "clsx";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/editor-utils/components/documentEditor.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from "react";
+interface DocumentEditorProps {
+    readonly mode: "light" | "dark";
+}
+export declare function DocumentEditor(props: PropsWithChildren<DocumentEditorProps>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=documentEditor.d.ts.map

package/dist/editor-utils/components/documentEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentEditor.d.ts","sourceRoot":"","sources":["../../../editor-utils/components/documentEditor.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAE1C,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;CACjC;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,2CAI3E"}

package/dist/editor-utils/components/documentEditor.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export function DocumentEditor(props) {
+    const classes = ["document-editor", `${props.mode}-mode`];
+    return _jsx("div", { className: classes.join(" "), children: props.children });
+}

package/dist/editor-utils/components/editorToolbar.d.ts

@@ -0,0 +1,11 @@
+import { ReactElement } from "react";
+interface EditorToolbarComponent {
+}
+interface EditorToolbarProps {
+    readonly left?: ReactElement<EditorToolbarComponent>[];
+    readonly center?: ReactElement<EditorToolbarComponent>[];
+    readonly right?: ReactElement<EditorToolbarComponent>[];
+}
+export declare function EditorToolbar(props: EditorToolbarProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=editorToolbar.d.ts.map

package/dist/editor-utils/components/editorToolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editorToolbar.d.ts","sourceRoot":"","sources":["../../../editor-utils/components/editorToolbar.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAErC,UAAU,sBAAsB;CAAG;AAEnC,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC,sBAAsB,CAAC,EAAE,CAAC;IACvD,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,sBAAsB,CAAC,EAAE,CAAC;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,sBAAsB,CAAC,EAAE,CAAC;CACzD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,2CAgBtD"}

package/dist/editor-utils/components/editorToolbar.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function EditorToolbar(props) {
+    const left = props.left || [], center = props.center || [], right = props.right || [];
+    return (_jsxs("div", { className: "editor-toolbar", children: [_jsx("div", { className: "editor-toolbar--column editor-toolbar--left", children: left }), _jsx("div", { className: "editor-toolbar--column editor-toolbar--center", children: center }), _jsx("div", { className: "editor-toolbar--column editor-toolbar--right", children: right })] }));
+}

package/dist/editor-utils/components/editorWorksheet.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from "react";
+interface EditorWorksheetProps {
+    readonly onClick?: () => void;
+}
+export declare function EditorWorksheet(props: PropsWithChildren<EditorWorksheetProps>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=editorWorksheet.d.ts.map