@comet/admin-generator 8.17.1 → 9.0.0-beta.0

package/lib/commands/generate/generateGrid/generateGridToolbar.d.ts

@@ -1,15 +0,0 @@
-import { type FormattedMessageElement } from "../generate-command";
-type Options = {
-    componentName: string;
-    forwardToolbarAction: boolean | undefined;
-    hasSearch: boolean;
-    hasFilter: boolean;
-    excelExport: boolean | undefined;
-    allowAdding: boolean;
-    instanceGqlType: string;
-    gqlType: string;
-    newEntryText: string | FormattedMessageElement | undefined;
-    fragmentName: string;
-};
-export declare const generateGridToolbar: ({ componentName, forwardToolbarAction, hasSearch, hasFilter, excelExport, allowAdding, instanceGqlType, gqlType, newEntryText, fragmentName, }: Options) => string;
-export {};

package/lib/commands/generate/generateGrid/generateGridToolbar.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateGridToolbar = void 0;
-const change_case_1 = require("change-case");
-const camelCaseToHumanReadable_1 = require("../utils/camelCaseToHumanReadable");
-const intl_1 = require("../utils/intl");
-const generateGridToolbar = ({ componentName, forwardToolbarAction, hasSearch, hasFilter, excelExport, allowAdding, instanceGqlType, gqlType, newEntryText, fragmentName, }) => {
-    return `${renderToolbarProps(componentName, !!forwardToolbarAction, !!excelExport)}
-    function ${componentName}(${getGridToolbarProps(componentName, !!forwardToolbarAction, !!excelExport)}) {
-        return (
-            <DataGridToolbar>
-                ${hasSearch ? "<GridToolbarQuickFilter />" : ""}
-                ${hasFilter ? "<GridFilterButton />" : ""}
-                <FillSpace />
-                ${renderToolbarActions({
-        forwardToolbarAction,
-        addItemText: (0, intl_1.generateFormattedMessage)({
-            config: newEntryText,
-            id: `${instanceGqlType}.${(0, change_case_1.camelCase)(fragmentName)}.newEntry`,
-            defaultMessage: `New ${(0, camelCaseToHumanReadable_1.camelCaseToHumanReadable)(gqlType)}`,
-            type: "jsx",
-        }),
-        excelExport,
-        allowAdding,
-    })}
-            </DataGridToolbar>
-        );
-    }`.replace(/^\s+\n/gm, "");
-};
-exports.generateGridToolbar = generateGridToolbar;
-const getGridToolbarProps = (componentName, toolbarAction, exportApi) => {
-    const props = [];
-    if (toolbarAction) {
-        props.push({
-            destructured: "toolbarAction",
-            typeDefinition: "toolbarAction?: ReactNode",
-        });
-    }
-    if (exportApi) {
-        props.push({
-            destructured: "exportApi",
-            typeDefinition: "exportApi: ExportApi",
-        });
-    }
-    if (!props.length) {
-        return "";
-    }
-    return `{
-        ${props.map((prop) => `${prop.destructured}`).join(",")}
-    }: ${componentName}ToolbarProps`;
-};
-const renderToolbarActions = ({ forwardToolbarAction, addItemText, excelExport, allowAdding }) => {
-    const showMoreActionsMenu = excelExport;
-    if (!showMoreActionsMenu && !allowAdding) {
-        return "";
-    }
-    const moreActionsMenu = `<CrudMoreActionsMenu
-        slotProps={{
-            button: {
-                responsive: true
-            }
-        }}
-        overallActions={[
-            ${excelExport
-        ? `{
-                        label: <FormattedMessage {...messages.downloadAsExcel} />,
-                        icon: exportApi.loading ? <CircularProgress size={20} /> : <ExcelIcon />,
-                        onClick: () => exportApi.exportGrid(),
-                        disabled: exportApi.loading,
-                    }`
-        : ""}
-        ]}
-    />`;
-    const defaultAddItemButton = `<Button responsive startIcon={<AddIcon />} component={StackLink} pageName="add" payload="add">
-        ${addItemText}
-    </Button>`;
-    const addAction = forwardToolbarAction ? "{toolbarAction}" : defaultAddItemButton;
-    return `
-        ${showMoreActionsMenu ? moreActionsMenu : ""}
-        ${allowAdding ? addAction : ""}`;
-};
-const renderToolbarProps = (componentName, forwardToolbarAction, exportApi) => {
-    if (forwardToolbarAction || exportApi) {
-        return `interface ${componentName}ToolbarProps extends GridToolbarProps {
-         ${forwardToolbarAction ? "toolbarAction: ReactNode;" : ""}
-         ${exportApi ? "exportApi: ExportApi;" : ""}
-}`;
-    }
-    return "";
-};

package/lib/commands/generate/generateGrid/getForwardedGqlArgs.d.ts

@@ -1,13 +0,0 @@
-import { type IntrospectionField } from "graphql";
-import { type Imports } from "../utils/generateImportsCode";
-import { type Prop } from "./generateGrid";
-export type GqlArg = {
-    type: string;
-    name: string;
-    queryOrMutationName: string;
-};
-export declare function getForwardedGqlArgs(gqlFields: IntrospectionField[]): {
-    imports: Imports;
-    prop: Prop;
-    gqlArg: GqlArg;
-}[];

package/lib/commands/generate/generateGrid/getForwardedGqlArgs.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getForwardedGqlArgs = getForwardedGqlArgs;
-function getForwardedGqlArgs(gqlFields) {
-    const ret = [];
-    const supportedGqlArgs = ["offset", "limit", "sort", "search", "filter", "input"]; // this arguments need to be handled differently or are already handled somewhere else
-    getArgs(gqlFields, supportedGqlArgs).forEach((arg) => {
-        let prop;
-        const imports = [];
-        if (arg.type === "ID" || arg.type === "String" || arg.type === "DateTime") {
-            prop = { name: arg.name, optional: false, type: "string" };
-        }
-        else if (arg.type === "Boolean") {
-            prop = { name: arg.name, optional: false, type: "boolean" };
-        }
-        else if (arg.type === "Int" || arg.type === "Float") {
-            prop = { name: arg.name, optional: false, type: "number" };
-        }
-        else if (arg.type === "JSONObject") {
-            prop = { name: arg.name, optional: false, type: "unknown" };
-        }
-        else {
-            prop = { name: arg.name, optional: false, type: `GQL${arg.type}` }; // generated types contain GQL prefix
-            imports.push({ name: `GQL${arg.type}`, importPath: "@src/graphql.generated" });
-        }
-        ret.push({ gqlArg: { name: arg.name, type: arg.type, queryOrMutationName: arg.gqlField.name }, prop, imports });
-    });
-    return ret;
-}
-function getArgs(gqlFields, skipGqlArgs) {
-    return gqlFields.reduce((acc, gqlField) => {
-        gqlField.args.forEach((gqlArg) => {
-            if (skipGqlArgs.includes(gqlArg.name))
-                return acc;
-            if (gqlArg.type.kind !== "NON_NULL" || gqlArg.defaultValue)
-                return acc;
-            const gqlType = gqlArg.type.ofType;
-            let type = "unknown";
-            if (gqlType.kind === "SCALAR") {
-                const nativeScalars = ["ID", "String", "Boolean", "Int", "Float", "DateTime", "JSONObject"];
-                if (!nativeScalars.includes(gqlType.name)) {
-                    // probably just add to gqlFields-array, but needs to be tested
-                    console.warn(`Currently not supported special SCALAR of type ${gqlType.name} in param ${gqlArg.name} of ${gqlField.name}`);
-                }
-                else {
-                    type = gqlType.name;
-                }
-            }
-            else if (gqlType.kind === "INPUT_OBJECT") {
-                type = gqlType.name;
-            }
-            else {
-                throw new Error(`Not supported kind ${gqlType.kind}, arg: ${gqlArg.name}`);
-            }
-            acc.push({ name: gqlArg.name, type, gqlArg, gqlField });
-        });
-        return acc;
-    }, []);
-}

package/lib/commands/generate/generateGrid/getPropsForFilterProp.d.ts

@@ -1,14 +0,0 @@
-import { type IntrospectionInputObjectType } from "graphql";
-import { type GridConfig } from "../generate-command";
-import { type Imports } from "../utils/generateImportsCode";
-import { type Prop } from "./generateGrid";
-export declare function getPropsForFilterProp<T extends {
-    __typename?: string;
-}>({ config, filterType, }: {
-    config: GridConfig<T>;
-    filterType: IntrospectionInputObjectType;
-}): {
-    hasFilterProp: boolean;
-    imports: Imports;
-    props: Prop[];
-};

package/lib/commands/generate/generateGrid/getPropsForFilterProp.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPropsForFilterProp = getPropsForFilterProp;
-function getPropsForFilterProp({ config, filterType, }) {
-    if (!config.filterProp)
-        return { hasFilterProp: false, imports: [], props: [] };
-    const filterTypeName = `GQL${filterType.name}`;
-    return {
-        hasFilterProp: true,
-        imports: [{ name: filterTypeName, importPath: "@src/graphql.generated" }],
-        props: [{ name: "filter", optional: true, type: filterTypeName }],
-    };
-}

package/lib/commands/generate/generateGrid/usableFields.d.ts

@@ -1,14 +0,0 @@
-type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-type GqlLeaves<T, FollowArrays extends boolean = false, Depth extends number = 5> = [Depth] extends [never] ? never : T extends any ? T extends Array<infer ArrayType> ? FollowArrays extends true ? GqlLeaves<ArrayType, FollowArrays, Prev[Depth]> : never : "__typename" extends keyof T ? {
-    [K in keyof T as K extends "__typename" ? never : K]-?: GqlLeaves<T[K], FollowArrays, Prev[Depth]>;
-} : never : never;
-type IfExplicitAny<T, Y, N> = T extends never ? Y : N;
-type FieldNames<T> = {
-    [K in keyof T]: `${Exclude<K, symbol>}${FieldNames<T[K]> extends never ? "" : `.${FieldNames<T[K]>}`}`;
-}[keyof T];
-export type UsableFields<T, FollowArrays extends boolean = false> = IfExplicitAny<T, any, FieldNames<GqlLeaves<T, FollowArrays>>>;
-type FormFieldNames<T> = {
-    [K in keyof T]: `${Exclude<K, symbol>}` | (FormFieldNames<T[K]> extends never ? never : `${Exclude<K, symbol>}.${FormFieldNames<T[K]>}`);
-}[keyof T];
-export type UsableFormFields<T> = IfExplicitAny<T, any, FormFieldNames<GqlLeaves<T, false>>>;
-export {};

package/lib/commands/generate/generateGrid/usableFields.js

@@ -1,3 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commands/generate/utils/camelCaseToHumanReadable.d.ts

@@ -1 +0,0 @@
-export declare function camelCaseToHumanReadable(s: string): string;

package/lib/commands/generate/utils/camelCaseToHumanReadable.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.camelCaseToHumanReadable = camelCaseToHumanReadable;
-const change_case_1 = require("change-case");
-function camelCaseToHumanReadable(s) {
-    return (0, change_case_1.capitalCase)(s);
-}

package/lib/commands/generate/utils/columnVisibility.d.ts

@@ -1,6 +0,0 @@
-import { type Breakpoint } from "@mui/material";
-type BreakpointKey = `'${Breakpoint}'` | number;
-type SingleValueBrakpointTypes = "up" | "down" | "only" | "not";
-type MultiValueBrakpointTypes = "between";
-export type ColumnVisibleOption = `${SingleValueBrakpointTypes}(${BreakpointKey})` | `${MultiValueBrakpointTypes}(${BreakpointKey}, ${BreakpointKey})` | false;
-export {};

package/lib/commands/generate/utils/columnVisibility.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commands/generate/utils/convertConfigImport.d.ts

@@ -1,6 +0,0 @@
-import { type Imports } from "./generateImportsCode";
-export declare function convertConfigImport(imprt: {
-    name: string;
-    import: string;
-    defaultImport?: boolean;
-}): Imports[0];

package/lib/commands/generate/utils/convertConfigImport.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertConfigImport = convertConfigImport;
-// generated code is one level below config, this function converts relative imports to go one level up
-function convertConfigImport(imprt) {
-    let importPath = imprt.import;
-    if (importPath.startsWith("../")) {
-        importPath = `../${importPath}`;
-    }
-    else if (importPath.startsWith("./")) {
-        importPath = `.${importPath}`;
-    }
-    return { name: imprt.name, importPath, defaultImport: imprt.defaultImport };
-}

package/lib/commands/generate/utils/findMutationType.d.ts

@@ -1,3 +0,0 @@
-import { type IntrospectionQuery } from "graphql";
-export declare function findMutationType(mutationName: string, schema: IntrospectionQuery): import("graphql").IntrospectionField | undefined;
-export declare function findMutationTypeOrThrow(mutationName: string, schema: IntrospectionQuery): import("graphql").IntrospectionField;

package/lib/commands/generate/utils/findMutationType.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findMutationType = findMutationType;
-exports.findMutationTypeOrThrow = findMutationTypeOrThrow;
-function findMutationType(mutationName, schema) {
-    if (!schema.__schema.mutationType)
-        throw new Error("Schema has no Mutation type");
-    const queryType = schema.__schema.types.find((type) => { var _a; return type.name === ((_a = schema.__schema.mutationType) === null || _a === void 0 ? void 0 : _a.name); });
-    if (!queryType)
-        throw new Error("Can't find Mutation type in gql schema");
-    return queryType.fields.find((field) => field.name === mutationName);
-}
-function findMutationTypeOrThrow(mutationName, schema) {
-    const ret = findMutationType(mutationName, schema);
-    if (!ret)
-        throw new Error(`Can't find Mutation ${mutationName} in gql schema`);
-    return ret;
-}

package/lib/commands/generate/utils/findQueryType.d.ts

@@ -1,2 +0,0 @@
-import { type IntrospectionQuery } from "graphql";
-export declare function findQueryTypeOrThrow(queryName: string, schema: IntrospectionQuery): import("graphql").IntrospectionField;

package/lib/commands/generate/utils/findQueryType.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findQueryTypeOrThrow = findQueryTypeOrThrow;
-function findQueryType(queryName, schema) {
-    const queryType = schema.__schema.types.find((type) => type.name === schema.__schema.queryType.name);
-    if (!queryType)
-        throw new Error("Can't find Query type in gql schema");
-    const ret = queryType.fields.find((field) => field.name === queryName);
-    if (!ret)
-        throw new Error(`Can't find query ${queryName} in gql schema`);
-    return ret;
-}
-function findQueryTypeOrThrow(queryName, schema) {
-    const ret = findQueryType(queryName, schema);
-    if (!ret)
-        throw new Error(`Can't find query ${queryName} in gql schema`);
-    return ret;
-}

package/lib/commands/generate/utils/findRootBlocks.d.ts

@@ -1,8 +0,0 @@
-import { type IntrospectionQuery } from "graphql";
-export declare function findRootBlocks({ gqlType, targetDirectory }: {
-    gqlType: string;
-    targetDirectory: string;
-}, schema: IntrospectionQuery): Record<string, {
-    import: string;
-    name: string;
-}>;

package/lib/commands/generate/utils/findRootBlocks.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findRootBlocks = findRootBlocks;
-const fs_1 = require("fs");
-const fallbackLibraryBlocks = {
-    AnchorBlock: "@comet/cms-admin",
-    DamImageBlock: "@comet/cms-admin",
-    DamVideoBlock: "@comet/cms-admin",
-    ExternalLinkBlock: "@comet/cms-admin",
-    InternalLinkBlock: "@comet/cms-admin",
-    PixelImageBlock: "@comet/cms-admin",
-    SpaceBlock: "@comet/cms-admin",
-    SvgImageBlock: "@comet/cms-admin",
-    YouTubeVideoBlock: "@comet/cms-admin",
-};
-function findRootBlocks({ gqlType, targetDirectory }, schema) {
-    const ret = {};
-    const schemaEntity = schema.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
-    if (!schemaEntity)
-        throw new Error("didn't find entity in schema types");
-    schemaEntity.fields.forEach((field) => {
-        if (ret[field.name])
-            return; // already defined
-        let type = field.type;
-        if (type.kind == "NON_NULL")
-            type = type.ofType;
-        if (type.kind == "SCALAR" && type.name.endsWith("BlockData")) {
-            let match = false;
-            const blockName = `${type.name.replace(/BlockData$/, "")}Block`;
-            const checkNames = [
-                {
-                    folderName: `${targetDirectory.replace(/\/generated$/, "")}/blocks`,
-                    import: `../blocks/${blockName}`,
-                },
-                {
-                    folderName: `src/common/blocks`,
-                    import: `@src/common/blocks/${blockName}`,
-                },
-            ];
-            for (const checkName of checkNames) {
-                if ((0, fs_1.existsSync)(`${checkName.folderName}/${blockName}.tsx`)) {
-                    match = true;
-                    ret[field.name] = {
-                        import: checkName.import,
-                        name: blockName,
-                    };
-                    break;
-                }
-            }
-            if (!match) {
-                const fallback = fallbackLibraryBlocks[blockName];
-                if (fallback) {
-                    ret[field.name] = {
-                        import: fallback,
-                        name: blockName,
-                    };
-                    match = true;
-                }
-            }
-            if (!match) {
-                throw new Error(`Didn't find admin block for ${blockName} in ${checkNames.map((c) => c.folderName).join(" or ")}`);
-            }
-        }
-    });
-    return ret;
-}

package/lib/commands/generate/utils/generateGqlOperation.d.ts

@@ -1,12 +0,0 @@
-export declare function generateGqlQueryTreeFromFields(fields: string[]): string;
-export declare function generateGqlOperation(options: {
-    type: "query" | "mutation";
-    operationName: string;
-    rootOperation: string;
-    variables?: {
-        name: string;
-        type: string;
-    }[];
-    fields: string[];
-    fragmentVariables?: string[];
-}): string;

package/lib/commands/generate/utils/generateGqlOperation.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateGqlQueryTreeFromFields = generateGqlQueryTreeFromFields;
-exports.generateGqlOperation = generateGqlOperation;
-function generateGqlQueryTreeFromFields(fields) {
-    // Helper to get or create a node at a given path
-    function getOrCreateNode(root, path) {
-        let node = root;
-        for (const part of path) {
-            if (!node.children[part]) {
-                node.children[part] = { children: {}, fragments: [] };
-            }
-            node = node.children[part];
-        }
-        return node;
-    }
-    // 1. create tree out of dot separated fields
-    const root = { children: {}, fragments: [] };
-    for (const field of fields) {
-        const fragmentMatch = field.match(/(.*)(\.{3}.*)/);
-        if (fragmentMatch) {
-            // e.g. foo.bar...Fragment
-            const key = fragmentMatch[1].trim();
-            const fragment = fragmentMatch[2].trim();
-            if (key === "") {
-                root.fragments.push(fragment);
-            }
-            else {
-                const path = key.split(".").filter(Boolean);
-                const node = getOrCreateNode(root, path);
-                node.fragments.push(fragment);
-            }
-        }
-        else {
-            // e.g. foo.bar.baz
-            const path = field.split(".").filter(Boolean);
-            if (path.length === 0)
-                continue;
-            // Mark the leaf node (no need to store field names, just ensure the path exists)
-            getOrCreateNode(root, path);
-        }
-    }
-    // 2. create fragment string out of tree
-    function recursiveStringify(node) {
-        const parts = [];
-        // Add fields (children)
-        for (const key of Object.keys(node.children)) {
-            const child = node.children[key];
-            const childStr = recursiveStringify(child);
-            if (childStr) {
-                parts.push(`${key} { ${childStr} }`);
-            }
-            else {
-                parts.push(key);
-            }
-        }
-        // Add fragments
-        if (node.fragments.length > 0) {
-            parts.push(...node.fragments);
-        }
-        return parts.join(" ");
-    }
-    return recursiveStringify(root);
-}
-function generateGqlOperation(options) {
-    var _a;
-    let queryArgs = "";
-    if (options.variables && options.variables.length > 0) {
-        queryArgs += `(`;
-        queryArgs += options.variables.map((v) => `$${v.name}: ${v.type}`).join(", ");
-        queryArgs += `)`;
-    }
-    let rootQueryArgs = "";
-    if (options.variables && options.variables.length > 0) {
-        rootQueryArgs += `(`;
-        rootQueryArgs += options.variables.map((v) => `${v.name}: $${v.name}`).join(", ");
-        rootQueryArgs += `)`;
-    }
-    return `
-    ${options.type} ${options.operationName}${queryArgs} {
-        ${options.rootOperation}${rootQueryArgs} {
-            ${generateGqlQueryTreeFromFields(options.fields)}
-        }
-    }
-    ${((_a = options.fragmentVariables) !== null && _a !== void 0 ? _a : []).join("\n")}
-    `;
-}

package/lib/commands/generate/utils/generateImportsCode.d.ts

@@ -1,6 +0,0 @@
-export type Imports = Array<{
-    name: string;
-    importPath: string;
-    defaultImport?: boolean;
-}>;
-export declare function generateImportsCode(imports: Imports): string;

package/lib/commands/generate/utils/generateImportsCode.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportsCode = generateImportsCode;
-// generate imports code and filter duplicates
-function generateImportsCode(imports) {
-    const importsNameToPath = new Map(); // name -> importPath
-    const filteredImports = imports.filter((imp) => {
-        if (importsNameToPath.has(imp.name)) {
-            if (importsNameToPath.get(imp.name) !== imp.importPath) {
-                throw new Error(`Duplicate import name ${imp.name}`);
-            }
-            else {
-                // duplicate import, skip
-                return false;
-            }
-        }
-        importsNameToPath.set(imp.name, imp.importPath);
-        return true;
-    });
-    const importsString = filteredImports
-        .map((imp) => {
-        if (imp.defaultImport) {
-            return `import ${imp.name} from "${imp.importPath}";`;
-        }
-        else {
-            return `import { ${imp.name} } from "${imp.importPath}";`;
-        }
-    })
-        .join("\n");
-    return importsString;
-}

package/lib/commands/generate/utils/intl.d.ts

@@ -1,20 +0,0 @@
-import { type ComponentProps, type ReactElement } from "react";
-import { FormattedMessage } from "react-intl";
-import { type FormattedMessageElement } from "../generate-command";
-type GenerateFormattedMessageOptions = ({
-    config: string | FormattedMessageElement | undefined;
-    defaultMessage: string;
-} | {
-    config: string | FormattedMessageElement;
-}) & {
-    id: string;
-    type: "jsx" | "intlCall";
-};
-export declare function isFormattedMessageElement(node: unknown): node is ReactElement<ComponentProps<typeof FormattedMessage>, typeof FormattedMessage>;
-/**
- * Generates a <FormattedMessage> JSX element or an intl.formatMessage call string supporting <FormattedMessage> config objects.
- *
- * either config or defaultMessage is required
- */
-export declare const generateFormattedMessage: (options: GenerateFormattedMessageOptions) => string;
-export {};

package/lib/commands/generate/utils/intl.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFormattedMessage = void 0;
-exports.isFormattedMessageElement = isFormattedMessageElement;
-const react_1 = require("react");
-const react_intl_1 = require("react-intl");
-function isFormattedMessageElement(node) {
-    return (0, react_1.isValidElement)(node) && node.type === react_intl_1.FormattedMessage;
-}
-/**
- * Generates a <FormattedMessage> JSX element or an intl.formatMessage call string supporting <FormattedMessage> config objects.
- *
- * either config or defaultMessage is required
- */
-const generateFormattedMessage = (options) => {
-    let id = options.id;
-    let defaultMessage = "";
-    if ("defaultMessage" in options) {
-        defaultMessage = options.defaultMessage;
-    }
-    if (isFormattedMessageElement(options.config)) {
-        if (!options.config.props.id) {
-            throw new Error("FormattedMessage requires an id");
-        }
-        id = options.config.props.id;
-        if (!options.config.props.defaultMessage) {
-            throw new Error("FormattedMessage requires an defaultMessage");
-        }
-        if (typeof options.config.props.defaultMessage !== "string") {
-            throw new Error("FormattedMessage requires a string defaultMessage");
-        }
-        defaultMessage = options.config.props.defaultMessage;
-    }
-    else if (typeof options.config === "string") {
-        defaultMessage = options.config;
-    }
-    if (options.type === "jsx") {
-        return `<FormattedMessage id=${JSON.stringify(id)} defaultMessage=${JSON.stringify(defaultMessage)} />`;
-    }
-    else {
-        return `intl.formatMessage({ id: ${JSON.stringify(id)}, defaultMessage: ${JSON.stringify(defaultMessage)} })`;
-    }
-};
-exports.generateFormattedMessage = generateFormattedMessage;

package/lib/commands/generate/utils/isFieldOptional.d.ts

@@ -1,7 +0,0 @@
-import { type IntrospectionQuery } from "graphql";
-import { type FormFieldConfig } from "../generate-command";
-export declare const isFieldOptional: ({ config, gqlIntrospection, gqlType, }: {
-    config: FormFieldConfig<any>;
-    gqlIntrospection: IntrospectionQuery;
-    gqlType: string;
-}) => boolean;

package/lib/commands/generate/utils/isFieldOptional.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFieldOptional = void 0;
-const isFieldOptional = ({ config, gqlIntrospection, gqlType, }) => {
-    if (config.required !== undefined) {
-        return !config.required;
-    }
-    if (config.readOnly) {
-        return true;
-    }
-    const schemaEntity = gqlIntrospection.__schema.types.find((type) => type.kind === "OBJECT" && type.name === gqlType);
-    if (!schemaEntity)
-        throw new Error(`didn't find entity ${gqlType} in schema types`);
-    if (schemaEntity.kind !== "OBJECT")
-        throw new Error(`kind of ${gqlType} is not object, but should be.`); // this should not happen
-    const fieldDef = schemaEntity.fields.find((field) => field.name === String(config.name));
-    if (!fieldDef)
-        return false;
-    return fieldDef.type.kind !== "NON_NULL";
-};
-exports.isFieldOptional = isFieldOptional;