generator-jhipster 8.7.0 → 8.7.1

package/dist/jdl/converters/json-to-jdl-entity-converter.js

@@ -1,293 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import JDLObject from '../models/jdl-object.js';
-import { JDLEntity, JDLEnum } from '../models/index.js';
-import JDLField from '../models/jdl-field.js';
-import JDLValidation from '../models/jdl-validation.js';
-import JDLRelationship from '../models/jdl-relationship.js';
-import JDLUnaryOption from '../models/jdl-unary-option.js';
-import JDLBinaryOption from '../models/jdl-binary-option.js';
-import { lowerFirst, upperFirst } from '../utils/string-utils.js';
-import { binaryOptions, fieldTypes, relationshipOptions, unaryOptions } from '../jhipster/index.js';
-import { asJdlRelationshipType } from '../jhipster/relationship-types.js';
-const { BlobTypes, CommonDBTypes, RelationalOnlyDBTypes } = fieldTypes;
-const { BUILT_IN_ENTITY } = relationshipOptions;
-const { FILTER, NO_FLUENT_METHOD, READ_ONLY, EMBEDDED } = unaryOptions;
-const { ANGULAR_SUFFIX, CLIENT_ROOT_FOLDER, DTO, MICROSERVICE, PAGINATION, SEARCH, SERVICE } = binaryOptions.Options;
-const { ANY, IMAGE, TEXT } = BlobTypes;
-const { BYTES } = RelationalOnlyDBTypes;
-export default {
-    convertEntitiesToJDL,
-};
-let entities;
-let jdlObject;
-/**
- * Convert the passed entities (parsed from JSON files) to a JDL object.
- * @param params - an object containing the entities and relevant options.
- * @param params.entities - a Map having for keys the entity names and values the JSON entity files.
- * @return the parsed entities in the JDL form.
- */
-export function convertEntitiesToJDL(entities) {
-    if (!entities) {
-        throw new Error('Entities have to be passed to be converted.');
-    }
-    init(entities);
-    addEntities();
-    addRelationshipsToJDL();
-    return jdlObject;
-}
-function init(ents) {
-    entities = ents;
-    jdlObject = new JDLObject();
-}
-function addEntities() {
-    entities.forEach((entity, entityName) => {
-        addEntity(entity, entityName);
-    });
-}
-function addEntity(entity, entityName) {
-    jdlObject.addEntity(convertJSONToJDLEntity(entity, entityName));
-    addEnumsToJDL(entity);
-    addEntityOptionsToJDL(entity, entityName);
-}
-function convertJSONToJDLEntity(entity, entityName) {
-    const jdlEntity = new JDLEntity({
-        name: entityName,
-        tableName: entity.entityTableName,
-        comment: entity.documentation,
-        annotations: entity.annotations,
-    });
-    addFields(jdlEntity, entity);
-    return jdlEntity;
-}
-function addFields(jdlEntity, entity) {
-    entity?.fields?.forEach(field => {
-        jdlEntity.addField(convertJSONToJDLField(field));
-    });
-}
-function convertJSONToJDLField(field) {
-    const jdlField = new JDLField({
-        name: lowerFirst(field.fieldName),
-        type: field.fieldType,
-        comment: field.documentation,
-    });
-    if (jdlField.type === BYTES) {
-        jdlField.type = getTypeForBlob(field.fieldTypeBlobContent);
-    }
-    addValidations(jdlField, field);
-    return jdlField;
-}
-function getTypeForBlob(blobContentType) {
-    if ([ANY, IMAGE, TEXT].includes(blobContentType)) {
-        return CommonDBTypes[`${blobContentType.toUpperCase()}_BLOB`];
-    }
-    throw new Error(`Unrecognised blob type: '${blobContentType}'`);
-}
-function addValidations(jdlField, field) {
-    if (field.fieldValidateRules) {
-        field.fieldValidateRules.forEach((rule) => {
-            jdlField.addValidation(convertJSONToJDLValidation(rule, field));
-        });
-    }
-}
-function convertJSONToJDLValidation(rule, field) {
-    return new JDLValidation({
-        name: rule,
-        value: field[`fieldValidateRules${upperFirst(rule)}`],
-    });
-}
-function addEnumsToJDL(entity) {
-    entity?.fields?.forEach((field) => {
-        if (field.fieldValues !== undefined) {
-            jdlObject.addEnum(new JDLEnum({
-                name: field.fieldType,
-                values: getEnumValuesFromString(field.fieldValues),
-                comment: field.fieldTypeDocumentation,
-            }));
-        }
-    });
-}
-function getEnumValuesFromString(valuesAsString) {
-    return valuesAsString.split(',').map(fieldValue => {
-        // if fieldValue looks like ENUM_VALUE (something)
-        if (fieldValue.includes('(')) {
-            const [key, value] = fieldValue
-                .replace(/^(\w+)\s\((\w+)\)$/, (match, matchedKey, matchedValue) => `${matchedKey},${matchedValue}`)
-                .split(',');
-            return {
-                key,
-                value,
-            };
-        }
-        return { key: fieldValue };
-    });
-}
-/*
- * Adds relationships for entities to JDL.
- * The jdl passed must contain the jdl entities concerned by the relationships
- */
-function addRelationshipsToJDL() {
-    entities.forEach((entity, entityName) => {
-        dealWithRelationships(entity.relationships, entityName);
-    });
-}
-function dealWithRelationships(relationships, entityName) {
-    if (!relationships) {
-        return;
-    }
-    relationships.forEach(relationship => {
-        if (relationship.relationshipSide === 'right') {
-            // Right side will be merged into the left side.
-            return;
-        }
-        const jdlRelationship = getRelationship(relationship, entityName);
-        if (jdlRelationship) {
-            jdlObject.addRelationship(jdlRelationship);
-        }
-    });
-}
-function getRelationship(relationship, entityName) {
-    const type = asJdlRelationshipType(relationship.relationshipType);
-    const options = getRelationshipOptions(relationship);
-    const sourceEntitySideAttributes = getSourceEntitySideAttributes(entityName, relationship);
-    const destinationEntityName = upperFirst(relationship.otherEntityName);
-    const destinationJDLEntity = jdlObject.getEntity(destinationEntityName);
-    const destinationEntity = entities.get(destinationEntityName);
-    let relationshipConfiguration = {
-        side: relationship.relationshipSide,
-        from: entityName,
-        to: destinationJDLEntity?.name ?? destinationEntityName,
-        type,
-        options,
-        injectedFieldInFrom: sourceEntitySideAttributes.injectedFieldInSourceEntity,
-        isInjectedFieldInFromRequired: sourceEntitySideAttributes.injectedFieldInSourceIsRequired,
-        commentInFrom: sourceEntitySideAttributes.commentForSourceEntity,
-        isInjectedFieldInToRequired: false,
-        injectedFieldInTo: null,
-        commentInTo: null,
-    };
-    relationshipConfiguration = {
-        ...relationshipConfiguration,
-        ...sourceEntitySideAttributes,
-    };
-    if (!destinationJDLEntity || !destinationEntity) {
-        if (relationshipConfiguration.options.global[BUILT_IN_ENTITY]) {
-            return new JDLRelationship(relationshipConfiguration);
-        }
-        return undefined;
-    }
-    const isEntityTheDestinationSideEntity = (otherEntityName, otherEntityRelationshipName) => otherEntityName === entityName && otherEntityRelationshipName === relationship.relationshipName;
-    const destinationSideAttributes = getDestinationEntitySideAttributes(isEntityTheDestinationSideEntity, destinationEntity.relationships);
-    relationshipConfiguration = {
-        ...relationshipConfiguration,
-        injectedFieldInTo: destinationSideAttributes.injectedFieldInDestinationEntity,
-        isInjectedFieldInToRequired: destinationSideAttributes.injectedFieldInDestinationIsRequired ?? false,
-        commentInTo: destinationSideAttributes.commentForDestinationEntity,
-    };
-    return new JDLRelationship(relationshipConfiguration);
-}
-function getSourceEntitySideAttributes(entityName, relationship) {
-    return {
-        sourceEntity: entityName,
-        injectedFieldInSourceEntity: getInjectedFieldInSourceEntity(relationship),
-        injectedFieldInSourceIsRequired: relationship.relationshipValidateRules,
-        commentForSourceEntity: relationship.documentation,
-    };
-}
-function getDestinationEntitySideAttributes(isEntityTheDestinationSideEntity, destinationEntityRelationships) {
-    const foundDestinationSideEntity = destinationEntityRelationships?.find(destinationEntityFromRelationship => {
-        return isEntityTheDestinationSideEntity(upperFirst(destinationEntityFromRelationship.otherEntityName), destinationEntityFromRelationship.otherEntityRelationshipName);
-    });
-    if (!foundDestinationSideEntity) {
-        return {};
-    }
-    // Bidirectional relationship
-    let injectedFieldInDestinationEntity = foundDestinationSideEntity.relationshipName;
-    if (!!foundDestinationSideEntity.otherEntityField && foundDestinationSideEntity.otherEntityField !== 'id') {
-        injectedFieldInDestinationEntity += `(${foundDestinationSideEntity.otherEntityField})`;
-    }
-    const injectedFieldInDestinationIsRequired = !!foundDestinationSideEntity.relationshipValidateRules;
-    const commentForDestinationEntity = foundDestinationSideEntity.documentation;
-    return {
-        injectedFieldInDestinationEntity,
-        injectedFieldInDestinationIsRequired,
-        commentForDestinationEntity,
-    };
-}
-function getRelationshipOptions(relationship) {
-    const options = {
-        global: {},
-        source: relationship.options ?? {},
-        destination: {},
-    };
-    if (relationship.relationshipWithBuiltInEntity) {
-        options.global[BUILT_IN_ENTITY] = true;
-    }
-    return options;
-}
-function getInjectedFieldInSourceEntity(relationship) {
-    return (relationship.relationshipName +
-        (relationship.otherEntityField && relationship.otherEntityField !== 'id' ? `(${relationship.otherEntityField})` : ''));
-}
-function addEntityOptionsToJDL(entity, entityName) {
-    if (entity.fluentMethods === false) {
-        addUnaryOptionToJDL(NO_FLUENT_METHOD, entityName);
-    }
-    [DTO, PAGINATION, SERVICE].forEach(option => {
-        if (entity[option] && entity[option] !== 'no') {
-            addBinaryOptionToJDL(option, entity[option], entityName);
-        }
-    });
-    if (entity.searchEngine) {
-        addBinaryOptionToJDL(SEARCH, entity.searchEngine, entityName);
-    }
-    // angularSuffix in BinaryOptions, angularJSSuffix in Json
-    if (entity.angularJSSuffix) {
-        addBinaryOptionToJDL(ANGULAR_SUFFIX, entity.angularJSSuffix, entityName);
-    }
-    // microservice in BinaryOptions, microserviceName in Json
-    if (entity.microserviceName !== undefined) {
-        addBinaryOptionToJDL(MICROSERVICE, entity.microserviceName, entityName);
-    }
-    if (entity.jpaMetamodelFiltering === true) {
-        addUnaryOptionToJDL(FILTER, entityName);
-    }
-    if (entity.readOnly === true) {
-        addUnaryOptionToJDL(READ_ONLY, entityName);
-    }
-    if (entity.embedded === true) {
-        addUnaryOptionToJDL(EMBEDDED, entityName);
-    }
-    if (entity.clientRootFolder) {
-        addBinaryOptionToJDL(CLIENT_ROOT_FOLDER, entity.clientRootFolder, entityName);
-    }
-}
-function addUnaryOptionToJDL(unaryOption, entityName) {
-    jdlObject.addOption(new JDLUnaryOption({
-        name: unaryOption,
-        entityNames: new Set([entityName]),
-    }));
-}
-function addBinaryOptionToJDL(binaryOption, value, entityName) {
-    jdlObject.addOption(new JDLBinaryOption({
-        name: binaryOption,
-        value,
-        entityNames: new Set([entityName]),
-    }));
-}

package/dist/jdl/converters/json-to-jdl-option-converter.js

@@ -1,43 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import JDLObject from '../models/jdl-object.js';
-import { unaryOptions } from '../jhipster/index.js';
-import JDLUnaryOption from '../models/jdl-unary-option.js';
-const { SKIP_CLIENT, SKIP_SERVER } = unaryOptions;
-export default {
-    convertServerOptionsToJDL,
-};
-/**
- * Parses the jhipster configuration into JDL.
- * @param config the jhipster config ('generator-jhipster' in .yo-rc.json)
- * @param jdl to which the parsed options are added. If undefined a new JDLObject is created.
- * @returns the JDLObject
- */
-export function convertServerOptionsToJDL(config, jdl) {
-    const jdlObject = jdl || new JDLObject();
-    const jhipsterConfig = config || {};
-    [SKIP_CLIENT, SKIP_SERVER].forEach(option => {
-        if (jhipsterConfig[option] === true) {
-            jdlObject.addOption(new JDLUnaryOption({
-                name: option,
-            }));
-        }
-    });
-    return jdlObject;
-}

package/dist/jdl/converters/parsed-jdl-to-jdl-object/application-converter.js

@@ -1,61 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import createJDLApplication from '../../models/jdl-application-factory.js';
-import ApplicationOptions from '../../jhipster/application-options.js';
-import { convertOptions } from './option-converter.js';
-const { OptionNames: { BASE_NAME }, } = ApplicationOptions;
-export default { convertApplications };
-/**
- * Converts parsed applications to JDL applications.
- * @param {Array<Object>} parsedApplications - the parsed applications.
- * @return {Array} the converted JDL applications.
- */
-export function convertApplications(parsedApplications) {
-    if (!parsedApplications) {
-        throw new Error('Applications have to be passed so as to be converted.');
-    }
-    return parsedApplications.map(parsedApplication => {
-        const jdlApplication = createJDLApplication(parsedApplication.config, parsedApplication.namespaceConfigs);
-        jdlApplication.addEntityNames(parsedApplication.entities);
-        const entityOptions = getEntityOptionsInApplication(parsedApplication);
-        checkEntityNamesInOptions(jdlApplication.getConfigurationOptionValue(BASE_NAME), entityOptions, parsedApplication.entities);
-        entityOptions.forEach(option => jdlApplication.addOption(option));
-        return jdlApplication;
-    });
-}
-function getEntityOptionsInApplication(parsedApplication) {
-    return convertOptions(parsedApplication.options, parsedApplication.useOptions || []);
-}
-/**
- * Checks whether the entity names used in the options are present in the entity names declared for the application.
- * @param applicationName - the application's name
- * @param entityOptions - the options declared in the application
- * @param entityNamesInApplication - the entity names declared in the application
- */
-function checkEntityNamesInOptions(applicationName, entityOptions, entityNamesInApplication) {
-    const entityNamesInApplicationSet = new Set(entityNamesInApplication);
-    entityOptions.forEach(option => {
-        const entityNamesForTheOption = option.resolveEntityNames(entityNamesInApplication);
-        entityNamesForTheOption.forEach(entityNameForTheOption => {
-            if (!entityNamesInApplicationSet.has(entityNameForTheOption)) {
-                throw new Error(`The entity ${entityNameForTheOption} in the ${option.name} option isn't declared in ${applicationName}'s entity list.`);
-            }
-        });
-    });
-}

package/dist/jdl/converters/parsed-jdl-to-jdl-object/deployment-converter.js

@@ -1,31 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import JDLDeployment from '../../models/jdl-deployment.js';
-export default { convertDeployments };
-/**
- * Converts a parsed JDL content corresponding to deployments to an array of JDLDeployment objects.
- * @param {Array} parsedDeployments - parsed JDL deployments.
- * @return the converted JDLDeployment objects.
- */
-export function convertDeployments(parsedDeployments) {
-    if (!parsedDeployments) {
-        throw new Error('Deployments have to be passed so as to be converted.');
-    }
-    return parsedDeployments.map(parsedDeployment => new JDLDeployment(parsedDeployment));
-}

package/dist/jdl/converters/parsed-jdl-to-jdl-object/entity-converter.js

@@ -1,47 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { lowerFirst } from 'lodash-es';
-import { JDLEntity } from '../../models/index.js';
-import { formatComment } from '../../utils/format-utils.js';
-export default { convertEntities };
-/**
- * Converts parsed entities to JDLEntity Objects.
- * @param {Array<Object>} parsedEntities - parsed entities from JDL content.
- * @param {Function} jdlFieldGetterFunction - the function called to retrieve JDL fields for an entity.
- * @returns converted JDLEntity objects.
- */
-export function convertEntities(parsedEntities, jdlFieldGetterFunction) {
-    if (!parsedEntities) {
-        throw new Error('Entities have to be passed so as to be converted.');
-    }
-    return parsedEntities.map(parsedEntity => {
-        const jdlEntity = new JDLEntity({
-            name: parsedEntity.name,
-            tableName: parsedEntity.tableName,
-            comment: formatComment(parsedEntity.documentation),
-            annotations: Object.fromEntries(parsedEntity.annotations?.map(annotation => [
-                lowerFirst(annotation.optionName),
-                annotation.type === 'UNARY' ? true : annotation.optionValue,
-            ]) ?? []),
-        });
-        const jdlFields = jdlFieldGetterFunction.call(undefined, parsedEntity);
-        jdlEntity.addFields(jdlFields);
-        return jdlEntity;
-    });
-}

package/dist/jdl/converters/parsed-jdl-to-jdl-object/enum-converter.js

@@ -1,44 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { JDLEnum } from '../../models/index.js';
-import { formatComment } from '../../utils/format-utils.js';
-export default { convertEnums };
-/**
- * Converts a parsed JDL content corresponding to enumerations to an array of JDLEnum objects.
- * @param {Array} enumerations - parsed JDL enumerations.
- * @return the converted JDLEnums.
- */
-export function convertEnums(enumerations) {
-    if (!enumerations) {
-        throw new Error('Enumerations have to be passed so as to be converted.');
-    }
-    return enumerations.map(enumeration => convertEnum(enumeration));
-}
-/**
- * Converts a parsed JDL content corresponding to an enumeration to a JDLEnum object.
- * @param {Object} enumeration - a parsed JDL enumeration.
- * @return the converted JDLEnum.
- */
-function convertEnum(enumeration) {
-    return new JDLEnum({
-        name: enumeration.name,
-        values: enumeration.values,
-        comment: formatComment(enumeration.documentation),
-    });
-}

package/dist/jdl/converters/parsed-jdl-to-jdl-object/field-converter.js

@@ -1,41 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import JDLField from '../../models/jdl-field.js';
-import { formatComment } from '../../utils/format-utils.js';
-import { lowerFirst } from '../../utils/string-utils.js';
-export default { convertField };
-/**
- * Converts a parsed JDL content corresponding to a field to a JDLField object.
- * @param {Object} field - a parsed JDL field.
- * @return the converted JDLField.
- */
-export function convertField(field) {
-    if (!field) {
-        throw new Error('A field has to be passed so as to be converted.');
-    }
-    const name = lowerFirst(field.name);
-    const jdlField = new JDLField({
-        name,
-        type: field.type,
-    });
-    if (field.documentation) {
-        jdlField.comment = formatComment(field.documentation);
-    }
-    return jdlField;
-}

package/dist/jdl/converters/parsed-jdl-to-jdl-object/option-converter.js

@@ -1,90 +0,0 @@
-/**
- * Copyright 2013-2024 the original author or authors from the JHipster project.
- *
- * This file is part of the JHipster project, see https://www.jhipster.tech/
- * for more information.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import JDLUnaryOption from '../../models/jdl-unary-option.js';
-import JDLBinaryOption from '../../models/jdl-binary-option.js';
-import { binaryOptions, unaryOptions } from '../../jhipster/index.js';
-const { OptionValues, getOptionName } = binaryOptions;
-export default { convertOptions };
-/**
- * Convert unary and binary options to JDLUnary & JDLBinary option classes.
- * @param {Object} parsedOptions - the parsed option object.
- * @param {Array<Object>} useOptions - the parsed option object, using the use form.
- * @returns {Array<JDLUnaryOption|JDLBinaryOption>} the converted JDLUnaryOption & JDLBinaryOption objects.
- */
-export function convertOptions(parsedOptions, useOptions) {
-    if (!parsedOptions) {
-        throw new Error('Options have to be passed so as to be converted.');
-    }
-    const convertedUnaryOptions = convertUnaryOptions(parsedOptions);
-    const convertedBinaryOptions = convertBinaryOptions(parsedOptions);
-    const convertedUseOptions = convertUseOptions(useOptions);
-    return [...convertedUnaryOptions, ...convertedBinaryOptions, ...convertedUseOptions];
-}
-function convertUnaryOptions(parsedOptions) {
-    const convertedUnaryOptions = [];
-    unaryOptions.forEach((unaryOptionName) => {
-        const parsedUnaryOption = parsedOptions[unaryOptionName];
-        if (!parsedUnaryOption || !parsedUnaryOption.list || parsedUnaryOption.list.length === 0) {
-            return;
-        }
-        convertedUnaryOptions.push(new JDLUnaryOption({
-            name: unaryOptionName,
-            entityNames: parsedUnaryOption.list,
-            excludedNames: parsedUnaryOption.excluded,
-        }));
-    });
-    return convertedUnaryOptions;
-}
-function convertBinaryOptions(parsedOptions) {
-    const convertedBinaryOptions = [];
-    binaryOptions.forEach((binaryOptionName) => {
-        if (!parsedOptions[binaryOptionName]) {
-            return;
-        }
-        const optionValues = Object.keys(parsedOptions[binaryOptionName]);
-        optionValues.forEach(optionValue => {
-            const parsedBinaryOption = parsedOptions[binaryOptionName][optionValue];
-            convertedBinaryOptions.push(new JDLBinaryOption({
-                name: binaryOptionName,
-                value: optionValue,
-                entityNames: parsedBinaryOption.list,
-                excludedNames: parsedBinaryOption.excluded,
-            }));
-        });
-    });
-    return convertedBinaryOptions;
-}
-function convertUseOptions(useOptions) {
-    const convertedUseOptions = [];
-    useOptions.forEach(useValue => {
-        const { optionValues, list, excluded } = useValue;
-        optionValues.forEach(optionValue => {
-            if (!OptionValues[optionValue]) {
-                return;
-            }
-            convertedUseOptions.push(new JDLBinaryOption({
-                name: getOptionName(OptionValues[optionValue]),
-                value: optionValue,
-                entityNames: list,
-                excludedNames: excluded,
-            }));
-        });
-    });
-    return convertedUseOptions;
-}