@equinor/fusion-framework-cli 10.7.4 → 11.0.0-next.0

package/dist/types/bin/app-build.d.ts

@@ -0,0 +1,52 @@
+import type { ReadResult as PackageInfo } from 'read-package-up';
+import type { AppManifest } from '@equinor/fusion-framework-module-app';
+import type { ConsoleLogger } from './utils';
+import type { RuntimeEnv } from '../lib';
+/**
+ * Options for building an application.
+ * @public
+ */
+export type BuildApplicationOptions = {
+    /**
+     * Partial runtime environment variables to override defaults.
+     */
+    env?: Partial<RuntimeEnv>;
+    /**
+     * Path to the application manifest file.
+     */
+    manifest?: string;
+    /**
+     * Logger instance for build output. If null, disables logging.
+     */
+    log?: ConsoleLogger | null;
+};
+/**
+ * Output of the application build process.
+ * @public
+ */
+type ApplicationBuildOutput = {
+    /**
+     * Package information from package.json.
+     */
+    pkg: PackageInfo;
+    /**
+     * Application manifest object.
+     */
+    manifest: AppManifest;
+    /**
+     * Output directory for the built application.
+     */
+    outDir: string;
+};
+/**
+ * Builds an application using Vite.
+ *
+ * Loads the application manifest, applies Vite configuration, and runs the Vite build process.
+ *
+ * @param opt - Build options including environment, manifest path, and logger.
+ * @returns Output containing package info, manifest, and output directory.
+ * @throws Will throw if the build process fails.
+ * @public
+ */
+export declare const buildApplication: (opt?: BuildApplicationOptions) => Promise<ApplicationBuildOutput>;
+export {};

package/dist/types/bin/app-check.d.ts

@@ -0,0 +1,31 @@
+import type { ConsoleLogger } from './utils';
+import { type FusionEnv, type FusionFrameworkSettings } from '../lib/framework.node.js';
+/**
+ * Options for checking application registration in the app store.
+ * @public
+ */
+type AppCheckOptions = {
+    /**
+     * The environment configuration for the Fusion Framework.
+     */
+    environment: FusionEnv;
+    /**
+     * Authentication settings for the Fusion Framework.
+     */
+    auth: FusionFrameworkSettings['auth'];
+    /**
+     * Optional logger for outputting progress and debug information.
+     */
+    log?: ConsoleLogger;
+};
+/**
+ * Checks if the application is registered in the app store.
+ *
+ * Resolves the app package and manifest, initializes the Fusion Framework, and queries the app store.
+ *
+ * @param options - Options for environment, authentication, and logging.
+ * @returns A promise that resolves when the check is complete.
+ * @public
+ */
+export declare const checkApp: (options: AppCheckOptions) => Promise<void>;
+export default checkApp;

package/dist/types/bin/app-config-publish.d.ts

@@ -0,0 +1,23 @@
+import { type FusionEnv, type FusionFrameworkSettings } from '../lib/framework.node.js';
+import { type ConsoleLogger } from './utils';
+type AppConfigPublishOptions = {
+    config?: string;
+    manifest?: string;
+    environment: Exclude<FusionEnv, FusionEnv.Development>;
+    auth: FusionFrameworkSettings['auth'];
+    debug?: boolean;
+    log?: ConsoleLogger | null;
+};
+/**
+ * Publishes the application configuration to the app store for a specific build version.
+ *
+ * This function generates the application config, loads the manifest, initializes the Fusion Framework,
+ * and sends the config to the app service. Handles and logs errors for common failure scenarios.
+ *
+ * @param options - Options for config, manifest, environment, authentication, and logging.
+ * @returns A promise that resolves when publishing is complete.
+ * @throws If the build version is missing or publishing fails.
+ * @public
+ */
+export declare const publishAppConfig: (options: AppConfigPublishOptions) => Promise<void>;
+export default publishAppConfig;

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

@@ -0,0 +1,52 @@
+import type { RuntimeEnv } from '../lib';
+import { type ConsoleLogger } from './utils';
+/**
+ * Options for generating the application configuration.
+ *
+ * This interface defines the shape of the options object accepted by
+ * {@link generateApplicationConfig}. It allows for optional logging, environment overrides,
+ * config file path, and output file path.
+ *
+ * @public
+ */
+interface GenerateApplicationConfigOptions {
+    /**
+     * Logger instance for outputting progress and debug information (optional).
+     */
+    log?: ConsoleLogger | null;
+    /**
+     * Partial runtime environment overrides (optional).
+     */
+    env?: Partial<RuntimeEnv>;
+    /**
+     * Path to the config file to resolve (optional).
+     */
+    config?: string;
+    /**
+     * Output file path for writing the generated config (optional).
+     */
+    output?: string;
+}
+/**
+ * Generates the application configuration object for the current project.
+ *
+ * This function resolves the app package, sets up the runtime environment, resolves the app config,
+ * and optionally writes the config to a file if an output path is provided. Logging is supported for
+ * debugging and progress tracking.
+ *
+ * @param options - Optional settings for logger, environment overrides, config path, and output file.
+ * @returns An object containing the generated config and the resolved package info.
+ * @throws If writing the config to file fails.
+ * @public
+ */
+export declare const generateApplicationConfig: (options?: GenerateApplicationConfigOptions) => Promise<{
+    config: {
+        environment: Record<string, any>;
+        endpoints?: Record<string, {
+            url: string;
+            scopes: string[];
+        }> | undefined;
+    };
+    pkg: import("../lib").ResolvedPackage;
+}>;
+export {};

package/dist/types/bin/app-dev.d.ts

@@ -0,0 +1,45 @@
+import type { RuntimeEnv } from '../lib/types.js';
+import type { ConsoleLogger } from './utils/ConsoleLogger.js';
+/**
+ * Options for starting the application development server.
+ *
+ * This interface defines the shape of the options object accepted by
+ * {@link startAppDevServer}. It allows for optional environment, manifest path,
+ * config path, and logger.
+ *
+ * @public
+ */
+export interface StartAppDevServerOptions {
+    /**
+     * Runtime environment settings for the dev server (optional).
+     */
+    env?: RuntimeEnv;
+    /**
+     * Path to the application manifest file (optional).
+     */
+    manifest?: string;
+    /**
+     * Path to the application config file (optional).
+     */
+    config?: string;
+    /**
+     * Logger instance for outputting progress and debug information (required).
+     */
+    log: ConsoleLogger | null;
+    /**
+     * Port for the development server (optional, defaults to 3000).
+     */
+    port?: number;
+}
+/**
+ * Starts the application development server for local development.
+ *
+ * This function resolves the app package, manifest, and config, sets up the runtime environment,
+ * and launches a development server using the resolved configuration. It also attempts to resolve
+ * the portal entry point if available, and provides detailed logging for each step.
+ *
+ * @param options - Settings for environment, manifest path, config path, and logger.
+ * @returns A promise that resolves when the dev server has started.
+ * @public
+ */
+export declare const startAppDevServer: (options?: StartAppDevServerOptions) => Promise<import("vite").ViteDevServer>;

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

@@ -0,0 +1,42 @@
+import type { RuntimeEnv } from '../lib';
+import type { ConsoleLogger } from './utils';
+/**
+ * Options for resolving the application manifest.
+ *
+ * This type defines the shape of the options object accepted by
+ * {@link loadAppManifest}. It allows for optional logging, environment overrides,
+ * and a custom manifest file path.
+ *
+ * @public
+ */
+export type ResolveAppManifestOptions = {
+    /**
+     * Logger instance for outputting progress and debug information (optional).
+     */
+    log?: ConsoleLogger | null;
+    /**
+     * Path to a specific manifest file to resolve (optional).
+     */
+    manifest?: string;
+    /**
+     * Partial runtime environment overrides (optional).
+     */
+    env?: Partial<RuntimeEnv>;
+};
+/**
+ * Loads and resolves the application manifest based on the provided options.
+ *
+ * This function resolves the app package, sets up the runtime environment, and loads the manifest.
+ * Logging is supported for debugging and progress tracking. Returns the manifest, package, and environment.
+ *
+ * @param options - The options for resolving the application manifest.
+ * @returns An object containing the resolved manifest, package, and runtime environment.
+ * @throws Will throw an error if resolving the application package or manifest fails.
+ * @public
+ */
+export declare const loadAppManifest: (options: ResolveAppManifestOptions) => Promise<{
+    manifest: import("@equinor/fusion-framework-module-app").AppManifest;
+    pkg: import("../lib").ResolvedPackage;
+    env: RuntimeEnv;
+}>;
+export default loadAppManifest;

package/dist/types/bin/app-pack.d.ts

@@ -0,0 +1,38 @@
+import type { ConsoleLogger } from './utils/ConsoleLogger';
+/**
+ * Options for bundling the application into an archive.
+ *
+ * This type defines the shape of the options object accepted by
+ * {@link bundleApp}. It allows for optional logging, manifest path, and archive name.
+ *
+ * @public
+ */
+export type BundleAppOptions = {
+    /**
+     * Logger instance for outputting progress and debug information (optional).
+     */
+    log?: ConsoleLogger | null;
+    /**
+     * Path to the application manifest file (optional).
+     */
+    manifest?: string;
+    /**
+     * Name or path of the output archive file (optional).
+     */
+    archive?: string;
+};
+/**
+ * Bundles the application into an archive for distribution or deployment.
+ *
+ * This function builds the application, validates the manifest, and creates an archive containing
+ * the app manifest and metadata. Handles errors and logs progress for maintainability and debugging.
+ *
+ * @param options - Options for logger, manifest path, and archive name.
+ * @returns An object containing the archive path and the application manifest.
+ * @throws If the manifest build config is missing or packaging fails.
+ * @public
+ */
+export declare const bundleApp: (options: BundleAppOptions) => Promise<{
+    archive: import("adm-zip");
+    manifest: import("@equinor/fusion-framework-module-app").AppManifest;
+}>;

package/dist/types/bin/app-tag.d.ts

@@ -0,0 +1,51 @@
+import type { FusionFramework } from '../lib';
+import { type ConsoleLogger } from './utils';
+/**
+ * Allowed tags for application versions in the app service.
+ *
+ * - `latest`: Marks the most recent stable version of the application.
+ * - `preview`: Marks a pre-release or preview version for testing or review.
+ *
+ * Used by {@link tagApplication} to validate and apply version tags.
+ *
+ * @public
+ */
+export declare enum AllowedTags {
+    Latest = "latest",
+    Preview = "preview"
+}
+/**
+ * Options for tagging an application version in the app service.
+ *
+ * This interface defines the required and optional parameters for the
+ * {@link tagApplication} function, including the tag type, application key,
+ * version, framework instance, and logger.
+ *
+ * @property tag - The tag to apply to the application version (e.g., 'latest' or 'preview').
+ * @property appKey - The unique key identifying the application.
+ * @property version - The version of the application to tag.
+ * @property framework - The FusionFramework instance used for service discovery and requests.
+ * @property log - Optional logger for outputting progress and debug information.
+ *
+ * @public
+ */
+export type TagApplicationOptions = {
+    tag: AllowedTags;
+    appKey: string;
+    version: string;
+    framework: FusionFramework;
+    log?: ConsoleLogger | null;
+};
+/**
+ * Tags an application version in the app service with a specified tag (e.g., 'latest' or 'preview').
+ *
+ * This function validates input, creates a client for the app service, and sends a tag request.
+ * It provides detailed logging and error handling for common failure scenarios.
+ *
+ * @param options - Tag, app key, version, framework instance, and logger.
+ * @returns The result of the tag operation from the app service.
+ * @throws If the tag, app key, or version is invalid, or if the tag operation fails.
+ * @public
+ */
+export declare const tagApplication: (options: TagApplicationOptions) => Promise<unknown>;
+export default tagApplication;

package/dist/types/bin/app-upload.d.ts

@@ -0,0 +1,40 @@
+import AdmZip from 'adm-zip';
+import type { ConsoleLogger } from './utils';
+import type { FusionFramework } from '../lib/framework.node.js';
+/**
+ * Options for uploading an application bundle to the app service.
+ *
+ * This type defines the required and optional parameters for the
+ * {@link uploadApplication} function, including the bundle file or AdmZip instance,
+ * application key, framework instance, and logger.
+ *
+ * @property fileOrBundle - Path to the bundle file or an AdmZip instance.
+ * @property appKey - Optional application key to override bundle metadata.
+ * @property framework - The FusionFramework instance used for service discovery and requests.
+ * @property log - Optional logger for outputting progress and debug information.
+ *
+ * @public
+ */
+type UploadApplicationOptions = {
+    fileOrBundle: string | AdmZip;
+    appKey?: string;
+    framework: FusionFramework;
+    log?: ConsoleLogger;
+};
+/**
+ * Uploads an application bundle to the app service for publishing or updating an app.
+ *
+ * This function loads the bundle, resolves the app key (from argument or metadata),
+ * reads the bundle content, and uploads it to the app service. Handles and logs errors
+ * for common failure scenarios, including HTTP status codes and bundle reading issues.
+ *
+ * @param opt - Options for bundle file, app key, framework, and logger.
+ * @returns The response from the app service, or an empty object if the response cannot be parsed.
+ * @throws If bundle reading or upload fails, or if the app service returns an error status.
+ * @public
+ */
+export declare const uploadApplication: (opt: UploadApplicationOptions) => Promise<{
+    name: string;
+    version: string;
+}>;
+export default uploadApplication;

package/dist/types/bin/helpers/load-bundle-metadata.d.ts

@@ -0,0 +1,15 @@
+import type AdmZip from 'adm-zip';
+/**
+ * The shape of the metadata loaded from the bundle zip file.
+ */
+export type BundleMetadata = {
+    name: string;
+    version: string;
+};
+/**
+ * Loads the metadata from a bundle zip file.
+ * @param bundle - The AdmZip instance representing the bundle.
+ * @returns A promise resolving to an object containing name and version.
+ * @throws If metadata.json is missing or cannot be parsed.
+ */
+export declare const loadMetadata: (bundle: AdmZip) => Promise<BundleMetadata>;

package/dist/types/bin/helpers/load-vite-config.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeEnv } from '../../lib';
+import { type ResolvedPackage } from '../../lib/utils';
+/**
+ * Loads and merges the Vite configuration for a given package and environment.
+ * Throws errors if the output directory is invalid (root or src).
+ *
+ * @param env - The runtime environment (mode, etc).
+ * @param pkg - The resolved package information.
+ * @returns The merged Vite UserConfig object.
+ */
+export declare const loadViteConfig: (env: RuntimeEnv, pkg: ResolvedPackage) => Promise<Record<string, any>>;
+export default loadViteConfig;

package/dist/types/bin/helpers/resolve-app-config.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeEnv } from '../../lib';
+import type { ConsoleLogger } from '../utils';
+import { type ApiAppConfig } from '../../lib/app';
+/**
+ * Resolves the application configuration based on the provided runtime environment and options.
+ * Handles logging, error reporting, and fallback to built-in config if no local config is found.
+ *
+ * @param env - The runtime environment containing the command and mode information.
+ * @param options - Optional parameters:
+ *   - config: Path to a specific configuration file.
+ *   - log: Logger utility for progress and status messages.
+ * @returns A promise resolving to the loaded application configuration.
+ * @throws If the application configuration cannot be resolved.
+ */
+export declare const resolveAppConfig: (env: RuntimeEnv, options: {
+    config?: string;
+    log?: ConsoleLogger | null;
+}) => Promise<ApiAppConfig>;

package/dist/types/bin/helpers/resolve-app-manifest.d.ts

@@ -0,0 +1,17 @@
+import type { RuntimeEnv, ResolvedPackage } from '../../lib';
+import type { ConsoleLogger } from '../utils';
+/**
+ * Resolves the application manifest for a given package and environment.
+ * Attempts to load a manifest file if specified, otherwise falls back to generating a manifest from package.json.
+ * Handles logging for progress, success, and error states.
+ *
+ * @param env - The runtime environment context.
+ * @param pkg - The resolved package information.
+ * @param options - Optional logger and manifest path.
+ * @returns The resolved application manifest object.
+ * @throws If the manifest file is explicitly requested but not found, or if another error occurs.
+ */
+export declare const resolveAppManifest: (env: RuntimeEnv, pkg: ResolvedPackage, options?: {
+    log?: ConsoleLogger | null;
+    manifestPath?: string;
+}) => Promise<import("@equinor/fusion-framework-module-app").AppManifest>;

package/dist/types/bin/helpers/resolve-portal-manifest.d.ts

@@ -0,0 +1,27 @@
+import type { RuntimeEnv } from '../../lib';
+import type { ConsoleLogger } from '../utils';
+import type { ResolvedPackage } from '../../lib/utils/resolve-package.js';
+import { type PortalManifest } from '../../lib/portal';
+/**
+ * Resolves the portal manifest for a given runtime environment and package.
+ *
+ * This function attempts to load a portal manifest, optionally merging it with a base manifest
+ * generated from the provided package's package.json. If a manifest file is not found and a
+ * manifest path was specified, an error is thrown. Otherwise, it falls back to the base manifest.
+ * Logging is performed at various stages if a logger is provided.
+ *
+ * @typeParam T - The shape of the portal manifest, extending Partial<PortalManifest>.
+ * @param env - The runtime environment context.
+ * @param pkg - The resolved package containing package.json metadata.
+ * @param options - Optional parameters.
+ * @param options.log - Optional logger for progress and error reporting.
+ * @param options.manifestPath - Optional path to a specific manifest file.
+ * @param options.base - Optional base manifest to merge with the loaded manifest.
+ * @returns A promise that resolves to the loaded or generated portal manifest.
+ * @throws {Error} If the manifest file is not found at the specified path or if another error occurs during loading.
+ */
+export declare const resolvePortalManifest: <T extends PortalManifest>(env: RuntimeEnv, pkg: ResolvedPackage, options?: {
+    log?: ConsoleLogger | null;
+    manifestPath?: string;
+    base?: Partial<T>;
+}) => Promise<T>;

package/dist/types/bin/helpers/resolve-project-package.d.ts

@@ -0,0 +1,13 @@
+import type { ConsoleLogger } from '../utils';
+/**
+ * Resolves the application package by fetching its metadata and logging relevant information.
+ *
+ * This function uses a logger to provide feedback during the resolution process.
+ * It retrieves the package's packageJson and root directory, logs the results, and handles errors gracefully.
+ *
+ * @param log - Logger instance for progress and status updates.
+ * @returns A promise that resolves to the package information, including its packageJson and root directory.
+ * @throws Will throw an error if the package resolution fails.
+ */
+export declare function resolveProjectPackage(log?: ConsoleLogger | null): Promise<import("../../lib").ResolvedPackage>;
+export default resolveProjectPackage;

package/dist/types/bin/index.d.ts

@@ -0,0 +1,9 @@
+export { buildApplication } from './app-build.js';
+export { bundleApp } from './app-pack.js';
+export { generateApplicationConfig } from './app-config.js';
+export { publishAppConfig } from './app-config-publish.js';
+export { startAppDevServer } from './app-dev.js';
+export { buildPortal } from './portal-build.js';
+export { bundlePortal } from './portal-pack.js';
+export { loadPortalManifest } from './portal-manifest.js';
+export { pack } from './pack.js';

package/dist/types/bin/pack.d.ts

@@ -0,0 +1,36 @@
+import AdmZip from 'adm-zip';
+import type { ReadResult as PackageInfo } from 'read-package-up';
+import { type ConsoleLogger } from './utils';
+/**
+ * Options for packaging an application bundle into a zip archive.
+ *
+ * This type defines the optional parameters for the {@link pack} function, including
+ * the build directory, archive output path, logger, and additional content to include.
+ *
+ * @property buildDir - Directory containing build output to include in the archive (default: 'dist').
+ * @property archive - Path to the output archive file (optional).
+ * @property log - Logger instance for outputting progress and debug information (optional).
+ * @property content - Additional files to include in the archive as a record of filename to content.
+ *
+ * @public
+ */
+type Options = {
+    buildDir?: string;
+    archive?: string;
+    log?: ConsoleLogger | null;
+    content?: Record<string, string>;
+};
+/**
+ * Packages an application build directory and additional files into a zip archive.
+ *
+ * This function validates the build directory, adds build output and standard files (e.g., package.json, README.md),
+ * and optionally writes the archive to disk. It supports adding extra content and provides detailed logging.
+ *
+ * @param pkg - The resolved package info from package.json.
+ * @param options - Packaging options including build directory, archive path, logger, and extra content.
+ * @returns The AdmZip instance representing the created archive.
+ * @throws If the build directory does not exist or writing the archive fails.
+ * @public
+ */
+export declare const pack: (pkg: PackageInfo, options?: Options) => Promise<AdmZip>;
+export default pack;

package/dist/types/bin/portal-build.d.ts

@@ -0,0 +1,54 @@
+import type { RuntimeEnv } from '../lib';
+import { type ConsoleLogger } from './utils';
+/**
+ * Options for building a portal application using Vite.
+ *
+ * This type defines the optional parameters for the {@link buildPortal} function, including
+ * environment overrides, manifest path, and logger instance.
+ *
+ * @property env - Partial runtime environment overrides (optional).
+ * @property manifest - Path to the portal manifest file (optional).
+ * @property log - Logger instance for outputting progress and debug information (optional).
+ *
+ * @public
+ */
+export type BuildApplicationOptions = {
+    env?: Partial<RuntimeEnv>;
+    manifest?: string;
+    log?: ConsoleLogger | null;
+};
+/**
+ * Builds a portal application using Vite.
+ *
+ * This function loads the portal manifest, applies Vite configuration, and runs the Vite build process.
+ * It provides detailed logging for each step and returns the package info, manifest, and output directory.
+ *
+ * @param opt - Build options including environment, manifest path, and logger.
+ * @returns An object containing the package info, manifest, and output directory.
+ * @throws If the build process fails or configuration is invalid.
+ * @public
+ */
+export declare const buildPortal: (opt?: BuildApplicationOptions) => Promise<{
+    pkg: import("../lib").ResolvedPackage;
+    manifest: {
+        build: {
+            version: string;
+            timestamp: string;
+            commitSha: string;
+            allowedExtensions: string[];
+            templateEntry: string;
+            schemaEntry: string;
+            config?: Record<string, unknown> | undefined;
+            githubRepo?: string | undefined;
+            projectPage?: string | undefined;
+            assetPath?: string | undefined;
+            annotations?: Record<string, string> | undefined;
+            schema?: Record<string, unknown> | undefined;
+        };
+        name: string;
+        displayName?: string | undefined;
+        description?: string | undefined;
+    };
+    outDir: any;
+}>;
+export default buildPortal;

package/dist/types/bin/portal-dev.d.ts

@@ -0,0 +1,37 @@
+import type { RuntimeEnv } from '../lib';
+import { type ConsoleLogger } from './utils';
+/**
+ * Starts the portal development server for local development and testing.
+ *
+ * This function sets up the runtime environment, resolves the portal manifest and config,
+ * and launches a development server using the resolved configuration. It provides detailed
+ * logging for each step and returns the dev server instance for further use.
+ *
+ * @param options - Settings for environment, manifest path, config path, logger, and server options.
+ * @returns The dev server instance after it has started.
+ * @public
+ */
+export declare const startPortalDevServer: (options?: {
+    /**
+     * Runtime environment settings for the dev server (optional).
+     */
+    env?: RuntimeEnv;
+    /**
+     * Path to the portal manifest file (optional).
+     */
+    manifest?: string;
+    /**
+     * Path to the portal config file (optional).
+     */
+    config?: string;
+    /**
+     * Logger instance for outputting progress and debug information (required).
+     */
+    log: ConsoleLogger | null;
+    /**
+     * Server options such as port (optional).
+     */
+    server?: {
+        port?: number;
+    };
+}) => Promise<import("vite").ViteDevServer>;