@equinor/fusion-framework-cli 10.0.0-widget-acdcb9b2 → 10.0.1

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

@@ -0,0 +1,5 @@
+/**
+ * when current application changes, this hook will observe the application module instances.
+ * If the module has Context and Navigation, this hook will navigate when the context changes
+ */
+export declare const useAppContextNavigation: () => void;

package/dist/types/bin/publish-application.d.ts

@@ -0,0 +1,6 @@
+import type { FusionEnv } from './utils/index.js';
+export declare const publishApplication: (options: {
+    tag: string;
+    env: FusionEnv;
+    service: string;
+}) => Promise<void>;

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

@@ -0,0 +1,12 @@
+import type { FusionEnv } from './utils/index.js';
+declare enum Tags {
+    preview = "preview",
+    latest = "latest"
+}
+export declare const tagApplication: (options: {
+    tag: keyof typeof Tags;
+    version: string;
+    env: FusionEnv;
+    service: string;
+}) => Promise<void>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { FusionEnv } from './utils/index.js';
+export declare const uploadApplication: (options: {
+    bundle: string;
+    env: FusionEnv;
+    service: string;
+}) => Promise<void>;

package/dist/types/bin/upload-export-config.d.ts

@@ -0,0 +1,10 @@
+import type { FusionEnv } from './utils/index.js';
+import { ConfigExecuterEnv } from '../lib/utils/config.js';
+export declare const uploadExportConfig: (options: {
+    command?: ConfigExecuterEnv["command"];
+    configFile: string;
+    version: string;
+    env: FusionEnv;
+    service: string;
+}) => Promise<void>;
+export default uploadExportConfig;

package/dist/types/bin/utils/execute-command.d.ts

@@ -0,0 +1,8 @@
+type Commands = {
+    app: {
+        build: '';
+        manifest: '';
+    };
+};
+export declare const executeCommand: <TProgram extends keyof Commands>(program: TProgram, command: keyof Commands[TProgram], ...options: any[]) => Promise<unknown>;
+export {};

package/dist/types/bin/utils/format.d.ts

@@ -1,4 +1,3 @@
-import { relative } from 'node:path';
 import chalk from 'chalk';
 export { chalk };
 export declare const formatPath: (path: string, opt?: {

package/dist/types/bin/utils/getEndpointUrl.d.ts

@@ -0,0 +1,10 @@
+export type FusionEnv = 'ci' | 'fqa' | 'tr' | 'fprd';
+/**
+ * Retreive full endpoint URI to env in service-discovery
+ * @param endpoint <string> The endpoint to call in+ uri
+ * @param fusionEnv <FusionEnv> The Fusion env to get uri for
+ * @param service <string> Custom service uri to use insted of Fusion
+ * @param version <string> The version of the api to use
+ * @returns <string> The uri with endpoint
+ */
+export declare const getEndpointUrl: (endpoint: string, fusionEnv: FusionEnv, service: string, version?: string) => Promise<string>;

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

@@ -0,0 +1,14 @@
+export { getEndpointUrl } from './getEndpointUrl.js';
+export type { FusionEnv } from './getEndpointUrl.js';
+export { requireToken } from './requireToken.js';
+export { isAppRegistered } from './isAppRegistered.js';
+export { loadAppConfig } from './load-app-config.js';
+export { loadAppManifest } from './load-manifest.js';
+export { loadPackage } from './load-package.js';
+export { loadViteConfig } from './load-vite-config.js';
+export { formatPath, formatByteSize } from './format.js';
+export { executeCommand } from './execute-command.js';
+export { publishAppConfig } from './publishAppConfig.js';
+export { tagAppBundle } from './tagAppBundle.js';
+export { uploadAppBundle } from './uploadAppBundle.js';
+export { Spinner } from './spinner.js';

package/dist/types/bin/utils/isAppRegistered.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Make sure the app is registerred in the app-service
+ * @param endpoint <string> The endpoint to make a call to
+ */
+export declare const isAppRegistered: (endpoint: string) => Promise<boolean>;

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

@@ -1,9 +1,10 @@
 import { type ConfigExecuterEnv } from '../../lib/utils/config.js';
 import { type ResolvedAppPackage } from '../../lib/app-package.js';
+import { ApiAppConfig } from '../../schemas.js';
 export declare const loadAppConfig: (env: ConfigExecuterEnv, pkg: ResolvedAppPackage, options?: {
     file?: string;
 }) => Promise<{
-    config: import("../../lib/app-config.js").AppConfig;
-    path?: string | undefined;
+    config: ApiAppConfig;
+    path?: string;
 }>;
 export default loadAppConfig;

package/dist/types/bin/utils/load-manifest.d.ts

@@ -1,9 +1,10 @@
+import type { AppManifest } from '@equinor/fusion-framework-module-app';
 import { type ConfigExecuterEnv } from '../../lib/utils/config.js';
 import { type ResolvedAppPackage } from '../../lib/app-package.js';
 export declare const loadAppManifest: (env: ConfigExecuterEnv, pkg: ResolvedAppPackage, options?: {
     file?: string;
 }) => Promise<{
-    manifest: import("../../lib/app-manifest.js").AppManifest;
-    path?: string | undefined;
+    manifest: AppManifest;
+    path?: string;
 }>;
 export default loadAppManifest;

package/dist/types/bin/utils/proxy-request-logger.d.ts

@@ -0,0 +1,15 @@
+import { type ClientRequest } from 'http';
+/**
+ * Logs the status of a proxy request using a spinner.
+ *
+ * @param proxyReq - The proxy request to log.
+ *
+ * The function attaches event listeners to the proxy request to handle
+ * 'response' and 'error' events. It uses a spinner to indicate the status
+ * of the request:
+ * - On a successful response (status code < 400), the spinner succeeds.
+ * - On a response with a status code >= 400, the spinner warns with the status message.
+ * - On an error, the spinner fails.
+ */
+export declare const proxyRequestLogger: (proxyReq: ClientRequest) => void;
+export default proxyRequestLogger;

package/dist/types/bin/utils/publishAppConfig.d.ts

@@ -0,0 +1,9 @@
+import { ApiAppConfig } from '../../schemas.js';
+/**
+ * Publishes app config to the apps-service endpoint
+ * @param endpoint string The endpoint to upload to
+ * @param appKey The application key
+ * @param config Object with app config
+ * @returns HTTP response as json
+ */
+export declare const publishAppConfig: (endpoint: string, appKey: string, config: ApiAppConfig) => Promise<any>;

package/dist/types/bin/utils/requireToken.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Make sure the user has a valid azure token.
+ */
+export declare const requireToken: () => void;

package/dist/types/bin/utils/spinner.d.ts

@@ -2,6 +2,7 @@ import { Options, type Ora } from 'ora';
 export declare class Spinner {
     #private;
     get ora(): Ora;
+    set attachConsole(value: boolean);
     static Global(options?: Options): Spinner;
     static Clone(spinner?: Spinner): Spinner;
     static get Current(): Spinner;

package/dist/types/bin/utils/tagAppBundle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Send request to apps-service to tag a bundle.
+ * @param endpoint string The endpoint to send request to.
+ * @param version string The version to tag the bundle with.
+ * @returns Response object as json.
+ */
+export declare const tagAppBundle: (endpoint: string, version: string) => Promise<any>;

package/dist/types/bin/utils/uploadAppBundle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Function that uploads a zip bundle to the endpoint.
+ * @param endpoint string The endpoint to upload to
+ * @param bundle string The filename to upload
+ * @returns Object
+ */
+export declare const uploadAppBundle: (endpoint: string, bundle: string) => Promise<any>;

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

@@ -1,27 +1,27 @@
+import { z } from 'zod';
 import { type ResolvedConfig, type FindConfigOptions, ConfigExecuterEnv } from './utils/config.js';
-import { ResolvedAppPackage } from './app-package.js';
-export type AppConfig = {
-    environment?: Record<string, unknown>;
-    endpoints?: Record<string, string>;
-};
+import { ApiAppConfig, ApiAppConfigSchema } from '../schemas.js';
 type FindAppConfigOptions = FindConfigOptions & {
     file?: string;
 };
 export type AppConfigFn = (env: ConfigExecuterEnv, args: {
-    base: AppConfig;
-}) => AppConfig | Promise<AppConfig>;
-export type AppConfigExport = AppConfig | AppConfigFn;
+    base: ApiAppConfig;
+}) => z.input<typeof ApiAppConfigSchema> | Promise<z.input<typeof ApiAppConfigSchema> | void> | void;
+export type AppConfigExport = ApiAppConfig | AppConfigFn;
 export declare const appConfigFilename = "app.config";
-export declare function assertAppConfig(value: AppConfig): asserts value;
 export declare const defineAppConfig: (fn: AppConfigFn) => AppConfigFn;
-export declare const mergeAppConfigs: (base: Partial<AppConfig>, overrides: Partial<AppConfig>) => AppConfig;
-export declare const loadAppConfig: (filename?: string) => Promise<import("./utils/config.js").ConfigExecuter<AppConfig, import("./utils/config.js").ConfigExecuterArgs>>;
+export declare const loadAppConfig: (filename?: string) => Promise<import("./utils/config.js").ConfigExecuter<{
+    environment: Record<string, any>;
+    endpoints?: Record<string, {
+        url: string;
+        scopes: string[];
+    }> | undefined;
+}, import("./utils/config.js").ConfigExecuterArgs>>;
 export declare const resolveAppConfig: (options?: FindConfigOptions & {
     file?: string;
 }) => Promise<ResolvedConfig<AppConfigFn> | void>;
-export declare const createAppConfigFromPackage: (_pkg: ResolvedAppPackage) => AppConfig;
-export declare const createAppConfig: (env: ConfigExecuterEnv, base: AppConfig, options?: FindAppConfigOptions) => Promise<{
-    config: AppConfig;
+export declare const createAppConfig: (env: ConfigExecuterEnv, base: ApiAppConfig, options?: FindAppConfigOptions) => Promise<{
+    config: ApiAppConfig;
     path?: string;
 }>;
 export {};

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

@@ -1,30 +1,46 @@
 import { ResolvedAppPackage } from './app-package.js';
 import { type FindConfigOptions, type ResolvedConfig, ConfigExecuterEnv } from './utils/config.js';
 import { RecursivePartial } from './utils/types.js';
-export type AppManifest = {
-    version: string;
-    key: string;
-    entry: string;
-    name: string;
-    shortName: string;
-    description?: string;
-    admins?: string[];
-    owners?: string[];
-    main?: string;
-    icon?: string;
-    resource?: string[];
-};
+import { AppManifest } from '@equinor/fusion-framework-module-app';
 export type AppManifestFn = (env: ConfigExecuterEnv, args: {
     base: AppManifest;
-}) => AppManifest | Promise<AppManifest>;
+}) => Partial<AppManifest> | Promise<Partial<AppManifest> | void> | void;
 type FindManifestOptions = FindConfigOptions & {
     file?: string;
 };
+/** base filename for configuration files */
 export declare const manifestConfigFilename = "app.manifest.config";
+/**
+ * Define a manifest for an application
+ *
+ * @example
+ * ```ts
+ * export default defineAppManifest(async() => {
+ *    return {
+ *        ...AppManifest_properties
+ *    }
+ * })
+ * ```
+ * @param fnOrObj - defines the manifest as an object or callback
+ */
 export declare const defineAppManifest: (fn: AppManifestFn) => AppManifestFn;
 export declare function assertAppManifest(value: AppManifest): asserts value;
+/**
+ * @example
+ * ```ts
+ * export default defineAppManifest(base) => mergeManifests(base, {prop: value});
+ * ```
+ * @param base base manifest to merge with
+ * @param overrides target manifest to apply to base
+ * @returns deep merged manifest
+ */
 export declare const mergeManifests: (base: RecursivePartial<AppManifest>, overrides: RecursivePartial<AppManifest>) => AppManifest;
+/** loads manifestFn from file */
 export declare const loadManifest: (filename?: string) => Promise<import("./utils/config.js").ConfigExecuter<AppManifest, import("./utils/config.js").ConfigExecuterArgs>>;
+/**
+ * tries to resolve manifest
+ * @see {@link resolveConfig | resolving config}
+ */
 export declare const resolveManifest: (options?: FindConfigOptions & {
     file?: string;
 }) => Promise<ResolvedConfig<AppManifestFn> | void>;

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

@@ -1,5 +1,5 @@
 import { PackageJson, type NormalizeOptions as ResolveAppPackageOptions } from 'read-package-up';
-import { AppManifest } from './app-manifest.js';
+import { AppManifest } from '@equinor/fusion-framework-module-app';
 export type AppPackageJson = PackageJson & {
     manifest?: AppManifest;
 };
@@ -16,8 +16,39 @@ export type ResolvedAppPackage = {
     path: string;
 };
 export declare function defineAppPackage(fnOrObject: DefinePackageExporter): DefinePackageExporter;
-export declare const resolveEntryPoint: (packageJson: Pick<PackageJson, 'main' | 'module'>) => string;
-export declare const resolveAppKey: (packageJson: Pick<PackageJson, 'name'>) => string;
-export declare const assertPackage: (_pkg: Partial<AppPackageJson>) => 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`.
+ *
+ * @param pkg - The resolved application package containing the package.json and path information.
+ * @returns The relative path to the resolved entry point.
+ * @throws Will throw an error if no entry point can be resolved.
+ */
+export declare const resolveEntryPoint: (packageJson: PackageJson, pkgPath?: string) => string;
+/**
+ * Resolves the application key from the given package.json object.
+ *
+ * @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.
+ */
+export declare const resolveAppKey: (packageJson: Pick<PackageJson, "name">) => string;
+/**
+ * Asserts the validity of a given package by resolving its application key and entry point.
+ *
+ * @param pkg - A partial representation of the application's package JSON.
+ */
+export declare const assertPackage: (pkg: Partial<AppPackageJson>) => void;
+/**
+ * Resolves the application package by searching for the nearest `package.json` file.
+ *
+ * @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.
+ */
 export declare const resolveAppPackage: (options?: ResolveAppPackageOptions) => Promise<ResolvedAppPackage>;
 export default resolveAppPackage;

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

@@ -1,6 +1,3 @@
-export { mergeManifests, defineAppManifest, type AppManifest, type AppManifestFn, } from './app-manifest.js';
-export { mergeAppConfigs, defineAppConfig, type AppConfig, type AppConfigFn, type AppConfigExport, } from './app-config.js';
+export { mergeManifests, defineAppManifest, type AppManifestFn } from './app-manifest.js';
+export { defineAppConfig, type AppConfigFn, type AppConfigExport } from './app-config.js';
 export { defineAppPackage, resolveAppKey, resolveEntryPoint, type AppPackageJson, type ResolvedAppPackage, } from './app-package.js';
-export { mergeWidgetManifests, defineWidgetManifest, createWidgetManifest, type WidgetManifest, type WidgetManifestFn, } from './widget-manifest.js';
-export { mergeWidgetConfigs, defineWidgetConfig, type WidgetConfig, type WidgetConfigFn, type WidgetConfigExport, } from './widget-config.js';
-export { createDevConfig, type AppConfig as ProxyConfig } from './dev-config.js';

package/dist/types/lib/plugins/app-assets/app-asset-plugin.d.ts

@@ -0,0 +1,36 @@
+import { type FilterPattern, type Plugin } from 'vite';
+/**
+ * A Vite plugin to handle external resources in a library build.
+ *
+ * @param options - Configuration options for the plugin.
+ * @param options.name - Optional name for the emitted assets.
+ * @param options.include - Filter pattern to include specific files.
+ * @param options.exclude - Filter pattern to exclude specific files.
+ * @returns A Vite plugin object.
+ *
+ * @remarks
+ * This plugin is intended to be used only during the Vite library build process.
+ * It resolves asset IDs, emits assets, and exports them as URLs.
+ *
+ * @example
+ * ```typescript
+ * // vite.config.ts
+ * import { ExternalAppAssetPlugin } from '@equinor/fusion-framework-cli/plugins/app-assets-plugin';
+ *
+ * export default {
+ *   plugins: [
+ *     ExternalAppAssetPlugin({
+ *       name: 'my-asset',
+ *       include:  ['svg', 'png'],
+ *       exclude: 'node_modules/**',
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+export declare const AppAssetExportPlugin: (options?: {
+    name?: string;
+    include?: FilterPattern;
+    exclude?: FilterPattern;
+}) => Plugin;
+export default AppAssetExportPlugin;

package/dist/types/lib/plugins/app-assets/emit-asset.d.ts

@@ -0,0 +1,18 @@
+import { type PluginContext } from 'rollup';
+/**
+ * Synchronously emits an asset file based on the provided context and options.
+ *
+ * @param context - The plugin context used for emitting the file and logging warnings.
+ * @param id - The identifier of the asset, which may include a resource query.
+ * @param options - Optional parameters for customizing the emitted asset.
+ * @param options.name - The name template for the emitted asset file. Defaults to '[name].[ext]'.
+ * @param options.outDir - The output directory where the asset will be emitted. Defaults to 'dist'.
+ * @param options.assetsDir - The directory within the output directory where assets will be stored. Defaults to 'assets'.
+ * @returns The path of the emitted asset relative to the assets directory, or null if the asset content could not be read.
+ */
+export declare const emitAssetSync: (context: PluginContext, id: string, options?: {
+    name?: string;
+    outDir?: string;
+    assetsDir?: string;
+}) => string | null;
+export default emitAssetSync;

package/dist/types/lib/plugins/app-assets/extension-filter-pattern.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Creates a regular expression pattern to filter files based on their extensions.
+ *
+ * @param exts - An array of file extensions to include in the pattern.
+ * @returns A RegExp object that matches files with the specified extensions.
+ *
+ * @example
+ * ```typescript
+ * const pattern = createExtensionFilterPattern(['.js', '.ts']);
+ * console.log(pattern); // Output: /\.(js|ts)(\?.*)?$/
+ * ```
+ */
+export declare const createExtensionFilterPattern: (exts: string[]) => RegExp;
+export default createExtensionFilterPattern;

package/dist/types/lib/plugins/app-assets/index.d.ts

@@ -0,0 +1,3 @@
+export { default, AppAssetExportPlugin } from './app-asset-plugin.js';
+export { createExtensionFilterPattern } from './extension-filter-pattern.js';
+export { ASSET_EXTENSIONS as StandardIncludeAssetExtensions } from './static.js';

package/dist/types/lib/plugins/app-assets/read-asset-content.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reads the content of an asset synchronously.
+ *
+ * @param id - The identifier of the asset, which can include a query string.
+ * @returns The content of the asset as a Buffer if it exists, otherwise null.
+ *
+ * @remarks
+ * - If the asset content is already cached, it returns the cached content.
+ * - The function extracts the filename from the identifier by removing any query string.
+ * - If the file exists, it reads the content, caches it, and then returns it.
+ * - If the file does not exist, it logs a warning and returns null.
+ */
+export declare const readAssetContentSync: (id: string) => Buffer | null;
+export default readAssetContentSync;

package/dist/types/lib/plugins/app-assets/resolve-asset-id.d.ts

@@ -0,0 +1,16 @@
+import { type PluginContext, type PartialResolvedId } from 'rollup';
+/**
+ * Resolves the asset ID based on the provided context, ID, importer, and options.
+ *
+ * @param context - The plugin context used for resolving the ID.
+ * @param id - The asset ID to resolve.
+ * @param importer - The path of the module that is importing the asset.
+ * @param options - Optional resolution options.
+ * @returns A promise that resolves to a `PartialResolvedId` object or `null`.
+ *
+ * The function handles three cases:
+ * 1. If the ID is an absolute path, it returns an object with the ID, marked as external and resolved by the plugin.
+ * 2. If the ID is a relative path, it resolves the path relative to the importer and returns an object with the resolved ID, marked as external and resolved by the plugin.
+ * 3. For all other cases, it delegates the resolution to the context's resolve method.
+ */
+export declare const resolveAssetId: (context: PluginContext, id: string, importer: string, options?: Parameters<PluginContext["resolve"]>[2]) => Promise<PartialResolvedId | null>;

package/dist/types/lib/plugins/app-assets/static.d.ts

@@ -0,0 +1,5 @@
+export declare const PLUGIN_NAME = "vite:fusion:app-assets";
+/**
+ * General asset extensions.
+ */
+export declare const ASSET_EXTENSIONS: string[];

package/dist/types/lib/plugins/app-proxy/app-proxy-plugin.d.ts

@@ -0,0 +1,71 @@
+import { Plugin } from 'vite';
+import { AppManifest } from '@equinor/fusion-framework-app';
+import { ClientRequest, IncomingMessage, ServerResponse } from 'node:http';
+import { ApiAppConfig } from '../../../schemas.js';
+/**
+ * Options for configuring the App Proxy Plugin.
+ *
+ * @remarks
+ * When not providing an app configuration, the plugin will only proxy requests to the target.
+ */
+export type AppProxyPluginOptions = {
+    /** Configuration for the proxy. */
+    proxy: {
+        /** The path to be proxied. */
+        path: string;
+        /** The target URL for the proxy. */
+        target: string;
+        /** Optional callback function to modify the proxy request. */
+        onProxyReq?: (proxyReq: ClientRequest, req: IncomingMessage, res: ServerResponse) => void;
+    };
+    /** Optional configuration for the app. */
+    app?: {
+        /** application key */
+        key: string;
+        /** application version */
+        version: string;
+        /** callback function for generating configuration for the application */
+        generateConfig: () => Promise<ApiAppConfig>;
+        /** callback function for generating manifest for the application */
+        generateManifest: () => Promise<AppManifest>;
+    };
+};
+/**
+ * The `appProxyPlugin` function creates a Vite plugin that configures a proxy for API and bundle requests
+ * to the Fusion apps backend. It also serves the app manifest, config, and local bundles if an app is provided.
+ *
+ * @param {AppProxyPluginOptions} options - The options for configuring the app proxy plugin.
+ *
+ * @returns {Plugin} - The configured Vite plugin.
+ *
+ * @example
+ * ```typescript
+ * const plugin = appProxyPlugin({
+ *   proxy: {
+ *     path: '/app-proxy',
+ *     target: 'https://fusion-s-apps-ci.azurewebsites.net/',
+ *     onProxyReq: (proxyReq, req, res) => {
+ *       proxyReq.on('response', (res) => { console.log(res.statusCode) });
+ *     },
+ *   },
+ *   app: {
+ *     key: 'my-app',
+ *     version: '1.0.0',
+ *     generateConfig: async () => ({}),
+ *     generateManifest: async () => ({}),
+ *   },
+ * });
+ *
+ * // api calls
+ * fetch('/app-proxy/apps/my-app/builds/1.0.0/config'); // will generate app config by provided function
+ * fetch('/app-proxy/apps/my-app/builds/0.0.9/config'); // will proxy to the target, since version does not match
+ * fetch('/app-proxy/apps/other-app/builds/1.0.0/config'); // will proxy to the target, since app key does not match
+ *
+ * // asset calls
+ * fetch('/app-proxy/bundles/my-app/builds/1.0.0/index.js'); // will generate bundle by provided function
+ * fetch('/app-proxy/bundles/my-app/builds/0.0.9/index.js'); // will proxy to the target, since version does not match
+ * ```
+ *
+ */
+export declare const appProxyPlugin: (options: AppProxyPluginOptions) => Plugin;
+export default appProxyPlugin;

package/dist/types/lib/plugins/app-proxy/index.d.ts

@@ -0,0 +1 @@
+export { default, appProxyPlugin, type AppProxyPluginOptions } from './app-proxy-plugin.js';

package/dist/types/lib/plugins/external-public/external-public-plugin.d.ts

@@ -0,0 +1,30 @@
+import { type FilterPattern, type Plugin } from 'vite';
+/**
+ * Creates a plugin that serves an external public directory.
+ *
+ * This plugin is useful when you want to serve a static site from a different directory than the one where the Vite server is running.
+ * Vite`s built in `mode: 'spa'` will only look for the `index.html` file in the configured `root` directory,
+ * so this plugin is necessary to serve the `index.html` file from a different directory.
+ *
+ * @param path - The path to the external public directory.
+ * @param options - Optional filter patterns to include or exclude specific assets.
+ * @param options.include - A filter pattern to include specific assets.
+ * @param options.exclude - A filter pattern to exclude specific assets.
+ * @returns A Vite plugin object.
+ *
+ * The plugin:
+ * - Sets the `path` configuration to the provided path.
+ * - Adds a middleware to the server that serves static assets from the specified path.
+ * - Adds a middleware to the server that serves the `index.html` file from the specified path.
+ *
+ * The middleware:
+ * - Checks if the request is for a static asset and serves it from the specified path.
+ * - Reads the `index.html` file from the specified path.
+ * - Transforms the HTML using the server's `transformIndexHtml` method.
+ * - Responds with the transformed HTML, setting appropriate headers.
+ */
+export declare const externalPublicPlugin: (path: string, options?: {
+    include?: FilterPattern;
+    exclude?: FilterPattern;
+}) => Plugin;
+export default externalPublicPlugin;

package/dist/types/lib/plugins/external-public/index.d.ts

@@ -0,0 +1 @@
+export { default, externalPublicPlugin } from './external-public-plugin.js';

package/dist/types/lib/utils/assert.d.ts

@@ -3,7 +3,8 @@ export { assert, AssertionError };
 export declare function assertNumber(value: unknown, message?: string): asserts value;
 export declare function assertObject(value: object, message?: string | Error): asserts value;
 declare function assertObjectEntryValue<P>(value: unknown, prop: P, message?: string): asserts value;
-export declare function assertObjectEntries<T extends object, P extends Array<keyof T>>(value: T, options?: {
+export declare function assertObjectEntries<T extends object, P extends Array<keyof T>>(// extends Record<string, unknown> = unknown>(
+value: T, options?: {
     props?: P;
     assertion?: typeof assertObjectEntryValue;
     preMessage?: string;

package/dist/types/lib/utils/config.d.ts

@@ -8,12 +8,12 @@ export type ResolveConfigOptions = {
     find?: FindConfigOptions;
 };
 export type ConfigExecuterEnv = {
+    /** cli command */
     command: 'serve' | 'build';
+    /** cli mode */
     mode: string;
+    /** root of the package */
     root?: string;
-    widget?: boolean;
-    port?: number;
-    outputFileName?: string;
 };
 export type ConfigExecuterArgs = [ConfigExecuterEnv, ...any[]];
 export type ConfigExecuter<TType = any, TArgs extends ConfigExecuterArgs = ConfigExecuterArgs> = (...args: TArgs) => TType | Promise<TType>;
@@ -22,8 +22,11 @@ export type ResolvedConfig<TType extends ConfigExecuter> = {
     path: string;
     config: TType;
 };
+/**
+ * @param filename name if config file without extension
+ */
 export declare const findConfigs: (filename: string, options?: FindConfigOptions) => Promise<string[]>;
-export declare const resolveConfig: <TType>(filename: string, options?: ResolveConfigOptions) => Promise<void | ResolvedConfig<ConfigExecuter<TType, ConfigExecuterArgs>>>;
-export declare const loadConfig: <TType>(file: string) => Promise<ConfigExecuter<TType, ConfigExecuterArgs>>;
-export declare function initiateConfig<TConfig extends ConfigExecuter>(config: TConfig, ...args: Parameters<TConfig>): Promise<ConfigExecuterType<TConfig>>;
+export declare const resolveConfig: <TType>(filename: string, options?: ResolveConfigOptions) => Promise<ResolvedConfig<ConfigExecuter<TType>> | void>;
+export declare const loadConfig: <TType>(file: string) => Promise<ConfigExecuter<TType>>;
+export declare function initiateConfig<TConfig extends ConfigExecuter>(config: TConfig, ...args: Parameters<TConfig>): Promise<ConfigExecuterType<TConfig> | void>;
 export default loadConfig;

package/dist/types/lib/utils/expect.d.ts

@@ -1,4 +1,4 @@
 export declare const expect: <T>(value: T) => {
     toBe: (expected: T, message: string) => asserts expected;
-    toBeInstanceOf: (expected: T, message: string) => asserts expected;
+    toBeInstanceOf: (expected: typeof value, message: string) => asserts expected;
 };

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

@@ -8,7 +8,7 @@ export declare const resolveViteConfig: (options?: FindConfigOptions & {
 export declare const createAppViteConfig: (env: ConfigExecuterEnv, options?: FindConfigOptions & {
     file?: string;
 }) => Promise<{
-    config: UserConfig;
+    config?: UserConfig;
     path?: string;
 } | void>;
 export declare const resolveEntryPoint: (cwd?: string, dir?: string, opt?: {