@equinor/fusion-framework-cli 10.7.5-apploader-be21a6b60eb13eee8bf869e75002d8634e9c50a9 → 11.0.0-next.1

package/dist/types/cli/commands/app/pack.d.ts

@@ -0,0 +1,31 @@
+export declare const defaultArchive = "app-bundle.zip";
+/**
+ * CLI command: `pack`
+ *
+ * Creates a distributable app bundle of the application.
+ *
+ * Features:
+ * - Bundles all necessary files for deployment.
+ * - Output filename and directory can be specified.
+ * - Optionally provide a manifest file to customize the bundle.
+ * - If no manifest is provided, defaults to app.manifest.[ts|js|json] in the current directory.
+ *
+ * Usage:
+ *   $ fusion pack [manifest] [options]
+ *
+ * Arguments:
+ *   [manifest]           Manifest file to use for bundling (e.g., app.manifest.ts)
+ *
+ * Options:
+ *   -a, --archive        Name of the output archive file (default: app-bundle.zip)
+ *   -o, --output         Directory where the archive will be saved (default: current working directory)
+ *   -d, --debug          Enable debug mode for verbose logging
+ *
+ * Example:
+ *   $ fusion pack
+ *   $ fusion pack app.manifest.dev.ts --archive my-app.zip --output ./dist
+ *
+ * @see bundleApp for implementation details
+ */
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/app/publish.d.ts

@@ -0,0 +1,31 @@
+/**
+ * CLI command: `publish`
+ *
+ * Builds, uploads, and tags a Fusion application for deployment to the Fusion portal.
+ *
+ * Features:
+ * - Bundles the app, uploads it to the Fusion app store, and applies a tag for versioning.
+ * - Supports specifying environment, manifest file, and tag.
+ * - Debug mode and authentication options are supported.
+ *
+ * Usage:
+ *   $ fusion publish [bundle] [options]
+ *
+ * Arguments:
+ *   [bundle]             Path to the app bundle to upload
+ *
+ * Options:
+ *   -d, --debug          Enable debug mode for verbose logging (default: false)
+ *   -e, --env <env>      Target environment
+ *   -m, --manifest       Manifest file to use for bundling (e.g., app.manifest.ts)
+ *   -t, --tag            Tag to apply to the published app (latest | preview)
+ *
+ * Example:
+ *   $ fusion publish
+ *   $ fusion publish --env prod --manifest app.manifest.prod.ts
+ *   $ fusion publish --tag latest app.bundle.zip
+ *
+ * @see uploadApplication, tagApplication for implementation details
+ */
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/app/tag.d.ts

@@ -0,0 +1,33 @@
+/**
+ * CLI command: `tag`
+ *
+ * Tags a Fusion application with a specific version or preview in the Fusion app registry.
+ *
+ * Features:
+ * - Applies a tag to the specified application version for release management.
+ * - App key and version can be provided or resolved from the manifest file.
+ * - Supports environment selection, debug, and silent modes.
+ *
+ * Usage:
+ *   $ fusion tag <tag> [options]
+ *
+ * Arguments:
+ *   <tag>                Tag to apply (latest | preview | stable)
+ *
+ * Options:
+ *   --appKey <string>    Application key (if not provided, resolved from manifest)
+ *   -v, --version <string> Version to tag (if not provided, resolved from manifest)
+ *   -m, --manifest <string> Manifest file to use for resolving app key and version
+ *   --debug              Enable debug mode for verbose logging
+ *   --silent             Silent mode, suppresses output except errors
+ *   -e, --env <env>      Target environment
+ *
+ * Example:
+ *   $ fusion tag latest
+ *   $ fusion tag preview --env prod --manifest app.manifest.prod.ts
+ *   $ fusion tag stable --appKey my-app --version 1.2.3
+ *
+ * @see tagApplication for implementation details
+ */
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/app/upload.d.ts

@@ -0,0 +1,29 @@
+/**
+ * CLI command: `upload`
+ *
+ * Uploads a Fusion application bundle to the Fusion App Store.
+ *
+ * Features:
+ * - Uploads a distributable application bundle (e.g., app-bundle.zip) to the Fusion app registry.
+ * - Supports specifying application key, environment, and debug mode.
+ *
+ * Usage:
+ *   $ fusion upload [bundle] [options]
+ *
+ * Arguments:
+ *   [bundle]             Application bundle to upload (default: app-bundle.zip)
+ *
+ * Options:
+ *   -k, --appKey <string> Application key (if not provided, resolved from manifest)
+ *   -e, --env <env>      Target environment
+ *   -d, --debug          Enable debug mode for verbose logging
+ *
+ * Example:
+ *   $ fusion upload
+ *   $ fusion upload my-app-bundle.zip --appKey my-app
+ *   $ fusion upload --debug
+ *
+ * @see uploadApplication for implementation details
+ */
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/auth/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const command: Command;
+export default command;

package/dist/types/cli/commands/auth/login.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/auth/logout.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Command to log out from Fusion Framework and clear your authentication session.
+ *
+ * This command removes your current authentication state from the Fusion Framework CLI.
+ * Supports custom tenant and client options for advanced scenarios.
+ *
+ * @example
+ *   $ fusion logout
+ *   $ fusion logout --tenant my-tenant --client my-client-id
+ */
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/auth/token.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Command to acquire and print an access token for Fusion APIs using your current authentication context.
+ *
+ * This command retrieves an access token for the specified scopes, tenant, and client.
+ * Supports debug and silent modes for flexible output.
+ *
+ * @example
+ *   $ fusion token
+ *   $ fusion token --scope api://my-app/.default
+ *   $ fusion token --tenant my-tenant --client my-client-id --silent
+ */
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/disco/index.d.ts

@@ -0,0 +1,2 @@
+declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/disco/resolve.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The `resolve` command resolves and displays information about a service registered in Fusion service discovery.
+ *
+ * This command looks up a service by name and prints its discovery details using the current authentication and environment.
+ *
+ * Supports environment selection and authentication options.
+ *
+ * ## Examples
+ *
+ * ```sh
+ * $ fusion resolve my-service
+ * $ fusion resolve my-service --env prod
+ * ```
+ *
+ * @command resolve
+ * @description Resolve and display information about a service registered in Fusion service discovery.
+ * @argument {string} service - Name of the service to resolve in Fusion service discovery.
+ * @option {string} --env - Environment to use (e.g., prod, test).
+ * @option {string} --token - Authentication token.
+ * @option {string} --tenantId - Tenant ID for authentication.
+ * @option {string} --clientId - Client ID for authentication.
+ * @returns {Promise<void>} Prints the resolved service details to the console.
+ */
+declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/portal/build.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/portal/dev.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/portal/index.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/portal/manifest.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/portal/pack.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/portal/publish.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/portal/schema.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/portal/tag.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/commands/portal/upload.d.ts

@@ -0,0 +1,2 @@
+export declare const command: import("commander").Command;
+export default command;

package/dist/types/cli/main.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Entry point for the Fusion Framework CLI.
+ *
+ * This file sets up the CLI program, loads the package metadata, and registers all available commands.
+ *
+ * Key responsibilities:
+ * - Locates the CLI's root directory and package.json using read-package-up.
+ * - Sets the CLI_BIN environment variable for internal use.
+ * - Initializes the Commander.js program with name, version, and description from package.json.
+ * - Registers all CLI commands via the registerCommands function.
+ * - Parses process arguments and starts the CLI.
+ *
+ * Maintenance notes:
+ * - To add new commands, update the registerCommands module.
+ * - To change CLI metadata (name, version, description), update package.json.
+ * - This file should remain minimal and only handle top-level CLI setup logic.
+ * - For troubleshooting, ensure the CLI_BIN path is set correctly and that package.json is accessible.
+ *
+ * For more details, see the Fusion Framework CLI documentation or contact the maintainers.
+ */
+export {};

package/dist/types/cli/options/auth.d.ts

@@ -0,0 +1,37 @@
+import { type Command } from 'commander';
+export declare const tenantOption: import("commander").Option;
+export declare const clientOption: import("commander").Option;
+export declare const tokenOption: import("commander").Option;
+export declare const scopeOption: import("commander").Option;
+/**
+ * Enhances a given command with authentication-related options.
+ *
+ * This function adds the following options to the provided command:
+ * - `tenantId`: Specifies the tenant identifier.
+ * - `clientId`: Specifies the client identifier.
+ * - `token`: Specifies the authentication token.
+ *
+ * @param command - The command to which authentication options will be added.
+ *
+ * @example
+ * ```ts
+ * import { createCommand } from 'commander';
+ * import { withAuthOptions } from './path/to/this/file';
+ * const command = withAuthOptions(
+ *   createCommand('my-command')
+ *     .description('My command description')
+ *     .action((options) => {
+ *       console.log('tenantId:', options.tenant);
+ *       console.log('clientId:', options.client);
+ *       console.log('token:', options.token);
+ *     })
+ * );
+ *
+ * withAuthOptions(command);
+ * ```
+ **/
+export declare const withAuthOptions: (command: Command, args?: Partial<{
+    excludeToken: boolean;
+    includeScope: boolean;
+}>) => Command;
+export default withAuthOptions;

package/dist/types/cli/options/env.d.ts

@@ -0,0 +1,19 @@
+import { FusionEnv } from '../../lib/framework.node.js';
+export type { FusionEnv } from '../../lib/framework.node.js';
+/**
+ * Creates an environment option for Fusion Framework CLI commands.
+ *
+ * @param options - Configuration options for the environment option.
+ * @param options.default - The default environment to use if not specified.
+ * @param options.allowDev - Whether to allow the development environment.
+ * @returns A configured Commander option for the environment.
+ */
+export declare const createEnvOption: (options: {
+    default?: FusionEnv;
+    allowDev: boolean;
+}) => import("commander").Option;
+/**
+ * Default environment option that allows the development environment.
+ */
+export declare const envOption: import("commander").Option;
+export default envOption;

package/dist/types/lib/app/app-config.d.ts

@@ -0,0 +1,31 @@
+import type z from 'zod';
+import type { RuntimeEnv } from '../types';
+import type { ApiAppConfig, ApiAppConfigSchema } from './schemas';
+export type { ApiAppConfig as AppConfig } from './schemas.js';
+export { mergeAppConfig } from './merge-app-config.js';
+/**
+ * A function type that defines the structure for configuring an application.
+ *
+ * This function receives the runtime environment and a base config, and returns
+ * either a config object, a promise resolving to a config object, or void.
+ *
+ * @template env - The runtime environment in which the application is running.
+ * @param env - The runtime environment object.
+ * @param args - An object containing the base API application configuration.
+ * @param args.base - The base configuration for the API application.
+ * @returns A value or a promise resolving to a value that matches the input type of `ApiAppConfigSchema`,
+ *          or `void` if no configuration is provided.
+ */
+export type AppConfigFn = (env: RuntimeEnv, args: {
+    base: ApiAppConfig;
+}) => z.input<typeof ApiAppConfigSchema> | Promise<z.input<typeof ApiAppConfigSchema> | void> | void;
+/**
+ * Defines the application configuration by accepting a function that returns the configuration object.
+ *
+ * This utility is typically used to encapsulate and organize application-specific settings
+ * in a structured and type-safe manner.
+ *
+ * @param fn - A function that returns the application configuration object.
+ * @returns The result of invoking the provided configuration function.
+ */
+export declare const defineAppConfig: (fn: AppConfigFn) => AppConfigFn;

package/dist/types/lib/app/app-manifest.d.ts

@@ -0,0 +1,39 @@
+import type { AppManifest } from '@equinor/fusion-framework-module-app';
+import type { RuntimeEnv } from '../types';
+/**
+ * Type representing the application manifest structure used by the Fusion Framework.
+ * Imported from the '@equinor/fusion-framework-module-app' package for consistency across modules.
+ */
+export type { AppManifest } from '@equinor/fusion-framework-module-app';
+/**
+ * Function type for loading or modifying an application manifest.
+ *
+ * @template T - A type extending Partial<AppManifest>, defaults to Partial<AppManifest>.
+ * @param env - The runtime environment (see '../types').
+ * @param args - Object containing the base manifest (`base`) of type T.
+ * @returns The modified manifest of type T, a promise resolving to T, or void if no changes are made.
+ *
+ * Usage: Implement this type to create functions that dynamically adjust the manifest based on environment or other factors.
+ *
+ * Inline notes:
+ * - This type is generic to allow for partial or full manifest overrides.
+ * - Returning void allows for side-effect-only functions, but returning the manifest is preferred for clarity.
+ */
+export type AppManifestFn<T extends AppManifest = AppManifest> = (env: RuntimeEnv, // The runtime environment, e.g., 'development', 'production', etc.
+args: {
+    base: T;
+}) => T | void | Promise<T | void>;
+/**
+ * Utility to define an application manifest in a type-safe and organized manner.
+ *
+ * @param fn - A function conforming to AppManifestFn that generates the manifest configuration.
+ * @returns The result of the provided function, representing the application manifest.
+ *
+ * Usage: Use this to encapsulate manifest logic, enabling better maintainability and discoverability for RAG systems.
+ *
+ * Inline notes:
+ * - This function is a higher-order utility for manifest definition, not execution.
+ * - It does not invoke the function immediately; it simply returns it for later use.
+ * - Helps with static analysis and RAG-based documentation extraction.
+ */
+export declare const defineAppManifest: (fn: AppManifestFn) => AppManifestFn<AppManifest>;

package/dist/types/lib/{app-package.d.ts → app/app-package.d.ts}

@@ -1,35 +1,44 @@
 import { type PackageJson, type NormalizeOptions as ResolveAppPackageOptions } from 'read-package-up';
 import type { AppManifest } from '@equinor/fusion-framework-module-app';
+/**
+ * Extended type for application package.json, optionally including a manifest.
+ */
 export type AppPackageJson = PackageJson & {
     manifest?: AppManifest;
 };
+/**
+ * Function type for defining a package, supporting both sync and async returns.
+ */
 type DefinePackageFn = () => AppPackageJson | Promise<AppPackageJson>;
+/**
+ * Structure representing a resolved application package, including its path and root directory.
+ */
 export type ResolvedAppPackage = {
     packageJson: AppPackageJson;
     path: string;
+    root: string;
 };
 /**
- * Method to define the application package with the given object.
+ * Defines the application package using the provided object.
  *
- * @param obj - The object to define the application package.
- * @returns The defined application package object.
+ * @param obj - The object representing the application package.
+ * @returns The same object, typed as AppPackageJson.
  */
 export declare function defineAppPackage(obj: AppPackageJson): AppPackageJson;
 /**
- * Method to define the application package with the given function.
+ * Defines the application package using a function.
  *
- * @param fn - The function to define the application package.
+ * @param fn - The function returning the application package.
  */
 export declare function defineAppPackage(fn: DefinePackageFn): void;
 /**
  * Resolves the entry point of a given package.
  *
- * This function attempts to find the entry point of a package by checking several
- * common properties in the package's `package.json` file, such as `entrypoint`, `main`,
- * and `module`. If none of these properties are found, it defaults to checking for
- * common entry files like `src/index.ts`, `src/index.tsx`, `src/index.js`, and `src/index.jsx`.
+ * This function checks for common entry point fields in the package.json (entrypoint, main, module),
+ * and falls back to typical source files if not found. It returns the first existing entry.
  *
- * @param pkg - The resolved application package containing the package.json and path information.
+ * @param packageJson - The package.json object to resolve from.
+ * @param pkgPath - The path to the package.json file (used for relative resolution).
  * @returns The relative path to the resolved entry point.
  * @throws Will throw an error if no entry point can be resolved.
  */
@@ -37,6 +46,8 @@ export declare const resolveEntryPoint: (packageJson: PackageJson, pkgPath?: str
 /**
  * Resolves the application key from the given package.json object.
  *
+ * This function strips any leading '@' or scope from the package name, returning a normalized key.
+ *
  * @param packageJson - An object containing the 'name' property from the package.json.
  * @returns The resolved application key, which is the package name with any leading '@' or scope removed.
  * @throws Will throw an error if the 'name' property is not present in the packageJson.
@@ -45,12 +56,18 @@ export declare const resolveAppKey: (packageJson: Pick<PackageJson, "name">) =>
 /**
  * Asserts the validity of a given package by resolving its application key and entry point.
  *
+ * This function is useful for validating that a package is correctly structured and can be used by the framework.
+ *
  * @param pkg - A partial representation of the application's package JSON.
+ * @throws Will throw if the package is missing a valid name or entry point.
  */
 export declare const assertPackage: (pkg: Partial<AppPackageJson>) => void;
 /**
  * Resolves the application package by searching for the nearest `package.json` file.
  *
+ * This function uses `read-package-up` to traverse up the directory tree and find the closest package.json.
+ * It returns the package contents, its path, and the root directory.
+ *
  * @param options - Optional parameters to customize the search behavior.
  * @returns A promise that resolves to the found package information.
  * @throws Will throw an error if the `package.json` file is not found.

package/dist/types/lib/app/create-app-manifest.d.ts

@@ -0,0 +1,17 @@
+import type { PackageJson } from 'type-fest';
+import type { AppManifest } from '@equinor/fusion-framework-module-app';
+import type { RuntimeEnv } from '../types.js';
+/**
+ * Creates an AppManifest object from the given runtime environment and package.json.
+ *
+ * This function extracts and normalizes manifest fields, resolves the entry point, asset path,
+ * and repository information, and includes build metadata. It is the main entry for generating
+ * a manifest for Fusion Framework applications.
+ *
+ * @param env - The runtime environment.
+ * @param packageJson - The application's package.json object.
+ * @returns The generated AppManifest object.
+ * @throws If required fields are missing in packageJson.
+ * @public
+ */
+export declare const createAppManifestFromPackage: (env: RuntimeEnv, packageJson: PackageJson) => AppManifest;

package/dist/types/lib/app/index.d.ts

@@ -0,0 +1,8 @@
+export { defineAppManifest, type AppManifestFn, type AppManifest } from './app-manifest.js';
+export { createAppManifestFromPackage } from './create-app-manifest.js';
+export { mergeAppManifests } from './merge-app-manifest.js';
+export { loadAppManifest, type AppManifestExport } from './load-app-manifest.js';
+export { mergeAppConfig } from './merge-app-config.js';
+export { defineAppConfig, type AppConfigFn, type AppConfig } from './app-config.js';
+export { loadAppConfig, type AppConfigExport } from './load-app-config.js';
+export { ApiAppConfigSchema, type ApiAppConfig } from './schemas.js';

package/dist/types/lib/app/load-app-config.d.ts

@@ -0,0 +1,54 @@
+import { type ImportConfigResult } from '@equinor/fusion-imports';
+import { type ApiAppConfig } from './schemas.js';
+import type { RuntimeEnv } from '../types.js';
+import type { AppConfigFn } from './app-config.js';
+/**
+ * Represents the configuration export for an application.
+ *
+ * This can either be a static configuration object (`ApiAppConfig`) or a function (`AppConfigFn`)
+ * that returns or modifies the application configuration dynamically.
+ *
+ * Used for both static and dynamic app config patterns.
+ *
+ * @remarks
+ * - Enables flexible config authoring for different deployment scenarios.
+ */
+export type AppConfigExport = ApiAppConfig | AppConfigFn;
+/**
+ * Options for loading an application config file.
+ *
+ * @property base - A base configuration object to merge with the imported configuration.
+ * @property file - The name of the configuration file to import. Defaults to 'app.config'.
+ * @property extensions - An array of file extensions to consider when resolving the configuration file.
+ *
+ * @remarks
+ * - Allows for custom config file resolution and merging strategies.
+ * - Useful for multi-environment setups and advanced config loading.
+ */
+export type LoadAppConfigOptions = {
+    base?: ApiAppConfig;
+    file?: string;
+    extensions?: string[];
+};
+/**
+ * Loads and resolves the application configuration from a file or function export.
+ *
+ * This function uses a script resolver to handle dynamic imports. If the imported module's default export
+ * is a function, it will be invoked with the runtime environment and the base configuration. The result
+ * is validated against the `ApiAppConfigSchema`. If the export is an object, it is validated directly.
+ *
+ * @param env - The runtime environment containing the root directory and other environment-specific settings.
+ * @param options - Optional parameters for configuring the import process.
+ * @returns A promise that resolves to the imported and validated application configuration.
+ *
+ * @remarks
+ * - Supports both static and dynamic config authoring patterns.
+ * - Ensures all configs are validated against the schema for type safety.
+ * - Designed for maintainability and RAG-based documentation extraction.
+ *
+ * @example
+ * ```ts
+ * const config = await loadAppConfig(env, { file: 'custom.config.ts' });
+ * ```
+ */
+export declare const loadAppConfig: (env: RuntimeEnv, options?: LoadAppConfigOptions) => Promise<ImportConfigResult<ApiAppConfig>>;

package/dist/types/lib/app/load-app-manifest.d.ts

@@ -0,0 +1,57 @@
+import type { AppManifest } from '@equinor/fusion-framework-module-app';
+import type { RuntimeEnv } from '../types.js';
+import type { AppManifestFn } from './app-manifest.js';
+/**
+ * Represents the export type for an application manifest, which can either be
+ * a static `AppManifest` object or a function (`AppManifestFn`) that generates
+ * an `AppManifest` dynamically based on the runtime environment.
+ *
+ * Used for both static and dynamic manifest patterns.
+ *
+ * @public
+ */
+export type AppManifestExport = AppManifest | AppManifestFn;
+/**
+ * Options for loading an application manifest file.
+ *
+ * @template T - The type of the application manifest, extending a partial `AppManifest`.
+ * @property base - A base manifest object to merge with the loaded manifest.
+ * @property file - The file path of the manifest to load. Defaults to `app.manifest` or environment-specific variants.
+ * @property extensions - An array of file extensions to consider when resolving the manifest.
+ */
+export type LoadAppManifestOptions = {
+    base?: AppManifest;
+    file?: string | string[];
+    extensions?: string[];
+};
+/**
+ * Represents the result of loading an application manifest.
+ *
+ * @template T - A type extending `Partial<AppManifest>` that represents the structure of the manifest.
+ * @property manifest - The loaded application manifest of type `T`.
+ * @property path - The file path where the manifest was loaded from.
+ * @property extension - The file extension of the manifest file.
+ */
+type LoadAppManifestResult = {
+    manifest: AppManifest;
+    path: string;
+    extension: string;
+};
+/**
+ * Loads an application manifest file and processes its contents.
+ *
+ * This function attempts to load a configuration file (defaulting to `app.manifest`) and resolves
+ * its contents using a provided script resolver. The manifest can either be a static object
+ * or a function that dynamically generates the manifest based on the runtime environment.
+ *
+ * If the specified file is not found and the runtime environment includes an `environment` property,
+ * the function will attempt to load a manifest file specific to that environment (e.g., `app.manifest.<environment>`).
+ *
+ * @param env - The runtime environment object, containing information such as the root directory and environment name.
+ * @param options - Optional parameters for loading the manifest.
+ * @returns A promise that resolves to an object containing the loaded manifest, the file path, and the file extension.
+ * @throws {FileNotFoundError} If the manifest file cannot be found and no fallback is available.
+ * @public
+ */
+export declare const loadAppManifest: (env: RuntimeEnv, options?: LoadAppManifestOptions) => Promise<LoadAppManifestResult>;
+export {};

package/dist/types/lib/app/merge-app-config.d.ts

@@ -0,0 +1,13 @@
+import type { AppConfig } from './app-config';
+/**
+ * Merges a base application configuration object with an overrides object,
+ * returning a new configuration object. If the `scopes` property is present
+ * in the overrides, it will replace the corresponding property in the base
+ * configuration instead of merging deeply.
+ *
+ * @typeParam T - The type of the application configuration object, extending `AppConfig`.
+ * @param base - The base configuration object to merge into.
+ * @param overrides - An object containing properties to override in the base configuration.
+ * @returns A new configuration object resulting from merging `base` and `overrides`.
+ */
+export declare const mergeAppConfig: <T extends AppConfig>(base: T, overrides: Partial<T>) => T;

package/dist/types/lib/app/merge-app-manifest.d.ts

@@ -0,0 +1,25 @@
+import type { AppManifest } from '@equinor/fusion-framework-module-app';
+import type { RecursivePartial } from '../utils/types.js';
+/**
+ * Deeply merges two application manifests using lodash's mergeWith.
+ *
+ * This utility is intended for combining a base manifest with an override manifest,
+ * supporting recursive merging of nested properties. It is commonly used in scenarios
+ * where environment-specific or user-specific manifest customizations are required.
+ *
+ * @example
+ * ```ts
+ * export default defineAppManifest(base => mergeAppManifests(base, { prop: value }));
+ * ```
+ *
+ * @param base - The base manifest to merge with. Typically the default or environment-agnostic manifest.
+ * @param overrides - The manifest containing properties to override or extend the base manifest.
+ * @returns The deeply merged manifest object.
+ *
+ * @remarks
+ * - Maintainers: This function does not perform schema validation. Ensure validation is handled elsewhere.
+ * - Future: Consider adding assertions or schema checks after merging for safety.
+ */
+export declare const mergeAppManifests: (base: RecursivePartial<AppManifest>, // The base manifest (may be partial)
+overrides: RecursivePartial<AppManifest>) => AppManifest;
+export default mergeAppManifests;