generator-jhipster 8.7.0 → 8.7.2

package/dist/lib/command/load.js

@@ -0,0 +1,76 @@
+import { upperFirst } from 'lodash-es';
+const prepareChoices = (key, choices) => choices
+    .map(choice => (typeof choice === 'string' ? { value: choice } : choice))
+    .filter(choice => choice.value != null)
+    .map(choice => ({ ...choice, choiceKey: `${key}${upperFirst(choice.value)}` }));
+const filteredScopeEntries = (commandsConfigs, scopes) => Object.entries(commandsConfigs).filter(([_key, def]) => scopes.includes(def.scope));
+function loadConfigIntoContext(options) {
+    const { applyDefaults, source, templatesContext, commandsConfigs, scopes = ['storage', 'blueprint'] } = options;
+    if (commandsConfigs) {
+        filteredScopeEntries(commandsConfigs, scopes).forEach(([key, def]) => {
+            let configuredValue = source?.[key] ?? templatesContext[key];
+            if (applyDefaults && def.default !== undefined && (configuredValue === undefined || configuredValue === null)) {
+                if (typeof def.default === 'function') {
+                    configuredValue = def.default.call(this, source);
+                }
+                else {
+                    configuredValue = def.default;
+                }
+            }
+            templatesContext[key] = configuredValue;
+            key = key === 'serviceDiscoveryType' ? 'serviceDiscovery' : key;
+            if (def.choices) {
+                const choices = prepareChoices(key, def.choices);
+                const hasConfiguredValue = configuredValue !== undefined && configuredValue !== null;
+                for (const { choiceKey, value: choiceValue } of choices) {
+                    if (hasConfiguredValue) {
+                        templatesContext[choiceKey] = configuredValue === choiceValue;
+                    }
+                    else {
+                        templatesContext[choiceKey] = templatesContext[choiceKey] ?? undefined;
+                    }
+                }
+                templatesContext[`${key}Any`] = hasConfiguredValue ? configuredValue !== 'no' : undefined;
+            }
+        });
+    }
+}
+export function loadCommandConfigsIntoApplication(options) {
+    const { application, commandsConfigs, source } = options;
+    loadConfigIntoContext.call(this, {
+        source,
+        templatesContext: application,
+        commandsConfigs,
+        scopes: ['storage', 'blueprint'],
+    });
+}
+export function loadCommandConfigsIntoGenerator(options) {
+    const { commandsConfigs } = options;
+    loadConfigIntoContext.call(this, {
+        source: this.options,
+        templatesContext: this,
+        commandsConfigs,
+        scopes: ['storage', 'blueprint'],
+    });
+}
+export function loadCommandConfigsKeysIntoTemplatesContext(options) {
+    const { templatesContext, commandsConfigs, scopes = ['storage', 'blueprint'] } = options;
+    if (commandsConfigs) {
+        filteredScopeEntries(commandsConfigs, scopes).forEach(([key, def]) => {
+            templatesContext[key] = templatesContext[key] ?? undefined;
+            if (def.choices) {
+                for (const { choiceKey } of prepareChoices(key, def.choices)) {
+                    templatesContext[choiceKey] = templatesContext[choiceKey] ?? undefined;
+                }
+                templatesContext[`${key}Any`] = templatesContext[`${key}Any`] ?? undefined;
+                if (key === 'serviceDiscoveryType') {
+                    key = 'serviceDiscovery';
+                    for (const { choiceKey } of prepareChoices(key, def.choices)) {
+                        templatesContext[choiceKey] = templatesContext[choiceKey] ?? undefined;
+                    }
+                    templatesContext[`${key}Any`] = templatesContext[`${key}Any`] ?? undefined;
+                }
+            }
+        });
+    }
+}

package/dist/lib/command/lookup-commands-configs.d.ts

@@ -0,0 +1,4 @@
+import type { JHipsterConfig, JHipsterConfigs } from './types.js';
+export declare const lookupCommandsConfigs: (options?: {
+    filter: (config: JHipsterConfig) => boolean;
+}) => Promise<JHipsterConfigs>;

package/dist/lib/command/lookup-commands-configs.js

@@ -0,0 +1,22 @@
+import { dirname, join } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { glob } from 'glob';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const cwd = join(__dirname, '../..');
+let jhipsterConfigs;
+export const lookupCommandsConfigs = async (options) => {
+    if (jhipsterConfigs) {
+        return jhipsterConfigs;
+    }
+    const { filter = () => true } = options ?? {};
+    jhipsterConfigs = {};
+    const files = [...(await glob('generators/*/index.{j,t}s', { cwd })), ...(await glob('generators/*/generators/*/index.{j,t}s', { cwd }))];
+    for (const file of files) {
+        const index = await import(pathToFileURL(`${cwd}/${file}`).toString());
+        if (index.command?.configs) {
+            Object.assign(jhipsterConfigs, index.command?.configs);
+        }
+    }
+    return Object.fromEntries(Object.entries(jhipsterConfigs).filter(([_key, value]) => filter(value)));
+};

package/dist/lib/command/support/merge-union.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Based on https://github.com/sindresorhus/type-fest/issues/610#issuecomment-2398118998
+ */
+import type { EmptyObject, IsNever, KeysOfUnion, Simplify, UnionToIntersection } from 'type-fest';
+
+type _MergeUnionKnownKeys<BaseType, Keys extends keyof BaseType = keyof BaseType> = {
+  [K in Keys]: Keys extends K ? BaseType[Keys] : never;
+};
+
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+
+export type MergeUnion<BaseType> =
+  IsNever<BaseType> extends false
+    ? Simplify<
+        _MergeUnionKnownKeys<BaseType> & {
+          [K in KeysOfUnion<BaseType>]?: BaseType extends object ? (K extends keyof BaseType ? BaseType[K] : never) : never;
+        }
+      >
+    : EmptyObject;

package/dist/lib/command/types.d.ts

@@ -0,0 +1,276 @@
+import type { ArgumentSpec, CliOptionSpec } from 'yeoman-generator';
+import type { IsNever, RequireAtLeastOne, SetOptional, Simplify, TaggedUnion, TupleToUnion, ValueOf } from 'type-fest';
+import type { JHipsterOptionDefinition } from '../jdl/core/types/parsing.js';
+import type { DerivedPropertiesOf, DerivedPropertiesWithInferenceUnion } from '../types/utils/derived-properties.js';
+import type { MergeUnion } from './support/merge-union.js';
+
+type CommandConfigScope = 'storage' | 'blueprint' | 'generator' | 'context' | 'none';
+
+export type ConfigScope = CommandConfigScope | 'control';
+type CliSpecType = CliOptionSpec['type'];
+
+export type JHispterChoices = readonly [...(string | { value: string; name: string })[]];
+
+export type JHipsterOption = SetOptional<CliOptionSpec, 'name'> & {
+  readonly name?: string;
+  readonly scope?: ConfigScope;
+  readonly env?: string;
+  readonly choices?: JHispterChoices;
+  readonly commandName?: string;
+};
+
+export type PromptSpec = {
+  readonly type: 'input' | 'list' | 'confirm' | 'checkbox';
+  readonly message: string | ((any) => string);
+  readonly when?: boolean | ((any) => boolean);
+  readonly default?: any | ((any) => any);
+  readonly filter?: any | ((any) => any);
+  readonly transformer?: any | ((any) => any);
+  readonly validate?: any | ((any) => any);
+};
+
+type JHipsterArgumentConfig = SetOptional<ArgumentSpec, 'name'> & { scope?: CommandConfigScope };
+
+type CliSpec = Omit<SetOptional<CliOptionSpec, 'name'>, 'storage'> & {
+  env?: string;
+  /**
+   * Imply other options.
+   */
+  implies?: Record<string, any>;
+};
+
+export type ConfigSpec<ConfigContext> = {
+  readonly description?: string;
+  readonly choices?: JHispterChoices;
+  readonly cli?: CliSpec;
+  readonly argument?: JHipsterArgumentConfig;
+  readonly internal?: true;
+  readonly prompt?:
+    | PromptSpec
+    | ((gen: ConfigContext & { jhipsterConfigWithDefaults: Record<string, any> }, config: ConfigSpec<ConfigContext>) => PromptSpec);
+  readonly jdl?: Omit<JHipsterOptionDefinition, 'name' | 'knownChoices'>;
+  readonly scope?: CommandConfigScope;
+  /**
+   * The callback receives the generator as input for 'generator' scope.
+   * The callback receives jhipsterConfigWithDefaults as input for 'storage' (default) scope.
+   * The callback receives blueprintStorage contents as input for 'blueprint' scope.
+   *
+   * Default value will not be applied to generator (using 'generator' scope) in initializing priority. Use cli.default instead.
+   * Default value will be application to templates context object (application) in loading priority.
+   */
+  readonly default?:
+    | string
+    | boolean
+    | number
+    | readonly string[]
+    | ((this: ConfigContext | void, ctx: any) => string | boolean | number | readonly string[]);
+  /**
+   * Configure the generator according to the selected configuration.
+   */
+  readonly configure?: (gen: ConfigContext) => void;
+};
+
+export type JHipsterArguments = Record<string, JHipsterArgumentConfig>;
+
+export type JHipsterOptions = Record<string, JHipsterOption>;
+
+export type JHipsterConfig<ConfigContext = any> = RequireAtLeastOne<
+  ConfigSpec<ConfigContext>,
+  'argument' | 'cli' | 'prompt' | 'jdl' | 'internal'
+>;
+
+export type JHipsterConfigs<ConfigContext = any> = Record<string, JHipsterConfig<ConfigContext>>;
+
+export type JHipsterCommandDefinition<ConfigContext = any> = {
+  readonly arguments?: JHipsterArguments;
+  readonly options?: JHipsterOptions;
+  readonly configs?: JHipsterConfigs<ConfigContext>;
+  /**
+   * Import options from a generator.
+   * @example ['server', 'jhipster-blueprint:server']
+   */
+  readonly import?: readonly string[];
+  /**
+   * @experimental
+   * Compose with generator.
+   * @example ['server', 'jhipster-blueprint:server']
+   */
+  readonly compose?: readonly string[];
+  /**
+   * Override options from the generator been blueprinted.
+   */
+  readonly override?: boolean;
+  /**
+   * Load old options definition (yeoman's `this.options()`) from the generator.
+   */
+  readonly loadGeneratorOptions?: boolean;
+};
+
+/**
+ * A simplified version of the `JHipsterCommandDefinition` type for types parsing.
+ */
+type ParseableConfig = {
+  readonly type?: CliSpecType;
+  readonly cli?: {
+    readonly type: CliSpecType;
+  };
+  readonly choices?: JHispterChoices;
+  readonly scope: ConfigScope;
+};
+
+type ParseableConfigs = Record<string, ParseableConfig>;
+
+type ParseableCommand = {
+  readonly options?: ParseableConfigs;
+  readonly configs?: ParseableConfigs;
+};
+
+/** Extract contructor return type, eg: Boolean, String */
+type ConstructorReturn<T> = T extends new () => infer R ? R : undefined;
+type FilteredConfigScope = ConfigScope | undefined;
+/** Add name to Options/Configs */
+type TaggedParseableConfigUnion<D> = D extends Record<string, any> ? Simplify<TaggedUnion<'name', D>> : never;
+
+/** Filter Options/Config by scope */
+type FilterScope<D extends ParseableConfig, S extends FilteredConfigScope> = D extends Record<'scope', S> ? D : never;
+
+type FilterCommandScope<D extends ParseableConfigs, S extends FilteredConfigScope> = {
+  [K in keyof D as IsNever<FilterScope<D[K], S>> extends true ? never : K]: D[K];
+};
+
+/**
+ * @example
+ * ```ts
+ * type MergedConfigsOptions = MergeConfigsOptions<{
+ *   configs: { clientFramework: { type: 'string'; scope: 'storage'; choices: ['angular', 'no'] } };
+ *   options: { clientTestFramework: { type: 'string'; scope: 'storage'; choices: ['cypress', 'no'] } };
+ * }>
+ * ```
+ */
+type MergeConfigsOptions<D extends ParseableCommand, S extends FilteredConfigScope> = Simplify<
+  (D extends { configs: ParseableConfigs } ? { [K in keyof FilterCommandScope<D['configs'], S>]: D['configs'][K] } : object) &
+    (D extends { options: ParseableConfigs } ? { [K in keyof FilterCommandScope<D['options'], S>]: D['options'][K] } : object)
+>;
+
+type GetType<C extends ParseableConfig> =
+  C extends Record<'type', CliSpecType> ? C['type'] : C extends Record<'cli', Record<'type', CliSpecType>> ? C['cli']['type'] : undefined;
+
+// eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
+type WrapperToPrimitive<T> = T extends Boolean ? boolean : T extends String ? string : T extends Number ? number : T;
+
+type GetChoiceValue<Choice extends string | { value: string }> = Choice extends string
+  ? Choice
+  : Choice extends { value: string }
+    ? Choice['value']
+    : never;
+
+/**
+ * @example
+ * type Normalized = NormalizeChoices<['angular', { value: 'no' }]>;
+ * type Normalized = ['angular', 'no'];
+ */
+type NormalizeChoices<Choices extends readonly [...(string | { value: string })[]]> = {
+  [Index in keyof Choices]: GetChoiceValue<Choices[Index]>;
+};
+
+/**
+ * @example
+ * ```ts
+ * type ExplodedCommandChoices = ExplodeCommandChoicesWithInference<{ clientFramework: { choices: ['angular', 'no'] }, clientTestFramework: { choices: ['cypress', 'no'] } }>
+ * {
+ *   clientFramework:
+ *     | { clientFrameworkAngular: true; clientFrameworkNo: false; clientFramework: 'angular'; clientFrameworkAny: true; };
+ *     | { clientFrameworkAngular: false; clientFrameworkNo: true; clientFramework: 'no'; clientFrameworkAny: false; }
+ *   clientTestFramework:
+ *     |{ clientTestFrameworkCypress: true; clientTestFrameworkNo: false; clientTestFramework: 'cypress'; clientTestFrameworkAny: true; };
+ *     |{ clientTestFrameworkCypress: false; clientTestFrameworkNo: true; clientTestFramework: 'no'; clientTestFrameworkAny: false; };
+ * }
+ * ```
+ */
+type DerivedPropertiesWithInferenceUnionFromParseableConfigs<U extends ParseableConfigs> = {
+  [K in keyof U]: U[K] extends infer RequiredChoices
+    ? RequiredChoices extends { choices: JHispterChoices }
+      ? K extends infer StringKey
+        ? StringKey extends string
+          ? NormalizeChoices<RequiredChoices['choices']> extends infer NormalizedChoices
+            ? // @ts-expect-error Mapped typle type is loosy https://github.com/microsoft/TypeScript/issues/27995
+              Simplify<DerivedPropertiesWithInferenceUnion<NormalizedChoices, StringKey>>
+            : never
+          : never
+        : never
+      : never
+    : never;
+};
+
+/**
+ * @example
+ * ```ts
+ * type ExplodedCommandChoices = ExplodeCommandChoicesNoInference<{ clientFramework: { choices: ['angular', 'no'], scope: 'storage' }, clientTestFramework: { choices: ['cypress', 'no'], scope: 'storage' } }>
+ * ```
+ */
+type ExplodeCommandChoicesNoInference<U extends ParseableConfigs> = {
+  [K in keyof U]: U[K] extends infer RequiredChoices
+    ? RequiredChoices extends { choices: any }
+      ? K extends infer StringKey
+        ? StringKey extends string
+          ? NormalizeChoices<RequiredChoices['choices']> extends infer NormalizedChoices
+            ? // @ts-expect-error Mapped typle type is loosy https://github.com/microsoft/TypeScript/issues/27995
+              Simplify<DerivedPropertiesOf<StringKey, NormalizedChoices[number]>>
+            : never
+          : never
+        : never
+      : never
+    : never;
+};
+
+type PrepareConfigsWithType<U extends ParseableConfigs> = Simplify<{
+  -readonly [K in keyof U]?: U[K] extends Record<'choices', JHispterChoices>
+    ? TupleToUnion<NormalizeChoices<U[K]['choices']>>
+    : WrapperToPrimitive<ConstructorReturn<GetType<U[K]>>> extends infer T
+      ? T extends undefined
+        ? unknown
+        : T
+      : never;
+}>;
+
+/** Keep Options/Config filtered by choices */
+type OnlyChoices<D, C extends boolean> = D extends { choices: JHispterChoices } ? (C extends true ? D : never) : C extends true ? never : D;
+
+/**
+ * Keep Options/Config filtered by choices
+ *
+ * @example
+ * ```ts
+ * type ConfigsWithChoice = OnlyConfigsWithChoice<{ clientFramework: { choices: ['angular', 'no'], scope: 'storage' }, clientTestFramework: { choices: ['cypress', 'no'], scope: 'storage' } }>
+ * ```
+ */
+type OnlyConfigsWithChoice<D extends ParseableConfigs, C extends boolean> = {
+  [K in keyof D as OnlyChoices<D[K], C> extends never ? never : K]: D[K];
+};
+
+/**
+ * @example
+ * ```
+ * type Prop = ExportApplicationPropertiesFromCommand<{ configs: { clientFramework: { choices: ['angular', 'no'], scope: 'storage' }, bar: { scope: 'storage' } } }>;
+ * ```
+ */
+export type ExportApplicationPropertiesFromCommand<C extends ParseableCommand> =
+  MergeConfigsOptions<C, 'storage'> extends infer Merged
+    ? Merged extends ParseableConfigs
+      ? // Add value inference to properties with choices
+        // ? PrepareConfigsWithType<OnlyConfigsWithChoice<F, false>> & ValueOf<ExplodeCommandChoicesWithInference<OnlyConfigsWithChoice<F, true>>>
+        Simplify<
+          PrepareConfigsWithType<OnlyConfigsWithChoice<Merged, false>> &
+            MergeUnion<ValueOf<ExplodeCommandChoicesNoInference<OnlyConfigsWithChoice<Merged, true>>>>
+        >
+      : never
+    : never;
+
+type ExportScopedPropertiesFromCommand<C extends ParseableCommand, S extends FilteredConfigScope> =
+  MergeConfigsOptions<C, S> extends infer Merged ? (Merged extends ParseableConfigs ? PrepareConfigsWithType<Merged> : never) : never;
+
+export type ExportStoragePropertiesFromCommand<C extends ParseableCommand> = ExportScopedPropertiesFromCommand<C, 'storage'>;
+
+export type ExportGeneratorOptionsFromCommand<C extends ParseableCommand> = ExportScopedPropertiesFromCommand<C, any>;
+
+export type ExportControlPropertiesFromCommand<C extends ParseableCommand> = ExportScopedPropertiesFromCommand<C, 'control'>;

package/dist/lib/eslint/base.d.ts

@@ -0,0 +1,8 @@
+export default baseConfig;
+/**
+ * @type {import('typescript-eslint').ConfigWithExtends}
+ *
+ * Config applied to transformed source in generation process.
+ * Rules must be compatible with auto fix to be applied.
+ */
+declare const baseConfig: import("typescript-eslint").ConfigWithExtends;

package/dist/lib/eslint/base.js

@@ -1,6 +1,5 @@
 import unusedImports from 'eslint-plugin-unused-imports';
-import imports from 'eslint-plugin-import';
-import { fixupPluginRules } from '@eslint/compat';
+import imports from 'eslint-plugin-import-x';
 /**
  * @type {import('typescript-eslint').ConfigWithExtends}
  *
@@ -10,7 +9,7 @@ import { fixupPluginRules } from '@eslint/compat';
 const baseConfig = {
     plugins: {
         'unused-imports': unusedImports,
-        import: fixupPluginRules(imports),
+        ...imports.flatConfigs.recommended.plugins,
     },
     rules: {
         'dot-notation': 'error',
@@ -29,16 +28,16 @@ const baseConfig = {
         'sort-imports': ['error', { ignoreDeclarationSort: true }],
         // Configure unused-imports rule
         'no-unused-vars': 'off',
-        'import/no-duplicates': 'error',
-        'import/order': 'error',
+        'import-x/no-duplicates': 'error',
+        'import-x/order': 'error',
         'unused-imports/no-unused-imports': 'error',
         'unused-imports/no-unused-vars': [
             'warn',
             {
                 vars: 'all',
-                varsIgnorePattern: '^_',
+                varsIgnorePattern: '^_[^_]',
                 args: 'after-used',
-                argsIgnorePattern: '^_',
+                argsIgnorePattern: '^_[^_]',
             },
         ],
     },

package/dist/lib/eslint/index.d.ts

@@ -0,0 +1,7 @@
+declare namespace _default {
+    export { recommended };
+    export { base };
+}
+export default _default;
+import recommended from './recommended.js';
+import base from './base.js';

package/dist/lib/eslint/index.js

@@ -1,4 +1,3 @@
 import recommended from './recommended.js';
 import base from './base.js';
-recommended.recommended = recommended;
-export default { ...recommended, recommended, base };
+export default { recommended, base };

package/dist/lib/eslint/recommended.d.ts

@@ -0,0 +1,3 @@
+export default recommended;
+/** @type {import('typescript-eslint').ConfigWithExtends} */
+declare const recommended: import("typescript-eslint").ConfigWithExtends;

package/dist/lib/index.d.ts

@@ -0,0 +1,4 @@
+export declare const isDistFolder: () => boolean;
+export declare const getPackageRoot: (relativePath?: string) => string;
+export declare const getSourceRoot: (relativePath?: string) => string;
+export declare const packageJson: any;

package/dist/lib/index.js

@@ -4,11 +4,15 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export const isDistFolder = () => {
-    return basename(join(__dirname, '..')) === 'dist';
+    return basename(dirname(__dirname)) === 'dist';
 };
 export const getPackageRoot = (relativePath) => {
-    const sourceRoot = join(__dirname, '..');
-    const packageDirectory = isDistFolder() ? join(sourceRoot, '..') : sourceRoot;
+    const sourceRoot = dirname(__dirname);
+    const packageDirectory = isDistFolder() ? dirname(sourceRoot) : sourceRoot;
     return relativePath ? join(packageDirectory, relativePath) : packageDirectory;
 };
+export const getSourceRoot = (relativePath) => {
+    const sourceRoot = dirname(__dirname);
+    return relativePath ? join(sourceRoot, relativePath) : sourceRoot;
+};
 export const packageJson = JSON.parse(readFileSync(getPackageRoot('package.json')).toString());

package/dist/lib/internal/config-def.d.ts

@@ -0,0 +1,12 @@
+import type { JHipsterConfigs } from '../../lib/command/index.js';
+import type CoreGenerator from '../../generators/base-core/index.js';
+export declare function loadConfig(this: CoreGenerator, configsDef: JHipsterConfigs | undefined, data: {
+    application: any;
+}): any;
+export declare function loadConfig(configsDef: JHipsterConfigs | undefined, data: {
+    application: any;
+    config?: any;
+}): any;
+export declare const loadDerivedConfig: (configsDef: JHipsterConfigs | undefined, { application }: {
+    application: any;
+}) => void;

package/dist/lib/internal/config-def.js

@@ -1,16 +1,4 @@
-import { upperFirstCamelCase } from '../../generators/base/support/string.js';
-export const convertConfigToOption = (name, config) => {
-    if (!config?.cli?.type)
-        return undefined;
-    const choices = config.choices?.map(choice => (typeof choice === 'string' ? choice : choice.value));
-    return {
-        name,
-        description: config.description,
-        choices,
-        scope: config.scope ?? 'storage',
-        ...config.cli,
-    };
-};
+import { upperFirstCamelCase } from '../utils/string.js';
 export function loadConfig(configsDef, { application, config }) {
     if (configsDef) {
         for (const [name, def] of Object.entries(configsDef)) {
@@ -18,19 +6,21 @@ export function loadConfig(configsDef, { application, config }) {
             if (value === undefined || value === null) {
                 let source = config;
                 if (!source) {
-                    if (def.scope === 'generator') {
-                        source = this;
+                    if (def.scope === 'context') {
+                        source = this.context;
                     }
                     else if (def.scope === 'blueprint') {
                         source = this.blueprintStorage.getAll();
                     }
-                    else {
+                    else if (def.scope === 'storage' || def.scope === undefined) {
                         source = this.jhipsterConfigWithDefaults;
                     }
                 }
-                value = application[name] = source[name] ?? undefined;
-                if (value === undefined && def.default !== undefined) {
-                    application[name] = typeof def.default === 'function' ? def.default.call(this, source) : def.default;
+                if (source) {
+                    value = application[name] = source[name] ?? undefined;
+                    if (value === undefined && def.default !== undefined) {
+                        application[name] = typeof def.default === 'function' ? def.default.call(this, source) : def.default;
+                    }
                 }
             }
         }
@@ -39,7 +29,7 @@ export function loadConfig(configsDef, { application, config }) {
 export const loadDerivedConfig = (configsDef, { application }) => {
     if (configsDef) {
         for (const [name, def] of Object.entries(configsDef)) {
-            if (def.choices) {
+            if ((def.scope === undefined || ['storage', 'blueprint', 'context'].includes(def.scope)) && def.choices) {
                 const configVal = application[name];
                 for (const choice of def.choices) {
                     const choiceVal = typeof choice === 'string' ? choice : choice.value;

package/dist/lib/jdl/converters/exporters/applications/jhipster-application-formatter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 type JDLApplication from '../../../core/models/jdl-application.js';
+import type { PostProcessedJDLJSONApplication } from '../../../core/types/exporter.js';
+/**
+ * Exports JDL applications to JDL files in separate folders (based on application base names).
+ * @param applications the applications to exporters (key: application name, value: a JDLApplication).
+ * @return object[] exported applications in their final form.
+ */
+export declare function formatApplicationsToExport(applications: Record<string, JDLApplication>): PostProcessedJDLJSONApplication[];
+/**
+ * Exports JDL a application to a JDL file in the current directory.
+ * @param {Object} application - the JDL application to export.
+ * @return {Object} the exported application in its final form.
+ */
+export declare function formatApplicationToExport(application: JDLApplication): PostProcessedJDLJSONApplication;

package/dist/lib/jdl/converters/exporters/export-utils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 type { JHipsterYoRcContent } from '../../core/types/json-config.js';
+export declare const GENERATOR_NAME = "generator-jhipster";
+/**
+ * This function writes a Yeoman config file in the current folder.
+ * @param config the configuration.
+ * @param yoRcPath the yeoman conf file path
+ */
+export declare function writeConfigFile(config: JHipsterYoRcContent, yoRcPath?: string): void;

package/dist/lib/jdl/converters/exporters/export-utils.js

@@ -0,0 +1,35 @@
+/**
+ * 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 fs from 'fs';
+import { doesFileExist } from '../../core/utils/file-utils.js';
+import { YO_RC_FILE, mergeYoRcContent, readYoRcFile } from '../../../utils/yo-rc.js';
+export const GENERATOR_NAME = 'generator-jhipster';
+/**
+ * This function writes a Yeoman config file in the current folder.
+ * @param config the configuration.
+ * @param yoRcPath the yeoman conf file path
+ */
+export function writeConfigFile(config, yoRcPath = YO_RC_FILE) {
+    let newYoRc = { ...config };
+    if (doesFileExist(yoRcPath)) {
+        const yoRc = readYoRcFile(yoRcPath);
+        newYoRc = mergeYoRcContent(yoRc, config);
+    }
+    fs.writeFileSync(yoRcPath, JSON.stringify(newYoRc, null, 2).concat('\n'));
+}