@junobuild/cli-tools 0.5.0 → 0.6.1

package/dist/types/commands/deploy.d.ts

@@ -1,5 +1,5 @@
 import type { CliConfig } from '@junobuild/config';
-import type { DeployParams, DeployResult, DeployResultWithProposal, UploadFileWithProposal } from '../types/deploy';
+import type { DeployParams, DeployResult, DeployResultWithProposal, UploadFilesWithProposal, UploadFileWithProposal, UploadIndividually, UploadWithBatch } from '../types/deploy';
 import type { ProposeChangesParams } from '../types/proposal';
 /**
  * Executes all configured pre-deploy hooks defined in the Juno configuration.
@@ -30,48 +30,63 @@ export declare const postDeploy: ({ config: { postdeploy } }: {
 /**
  * Prepares and uploads dapp assets to a satellite.
  *
- * This function handles:
- * 1. Resolving source files to upload.
- * 2. Verifying that enough memory is available (via `assertMemory`).
- * 3. Uploading all valid files using the provided `uploadFile` function.
+ * Steps:
+ * 1) Resolve source files to upload.
+ * 2) Ensure enough memory is available (via internal checks).
+ * 3) Upload files using the provided upload function:
+ *    - `UploadWithBatch`: one init+commit for all files (batched).
+ *    - `UploadIndividually`: init+commit per file (unbatched).
  *
- * If no files are detected (e.g., all files are unchanged), the deploy is skipped.
+ * Notes:
+ * - Chunk uploading logic is identical in both modes; only init/commit differ.
+ * - If no files are detected (e.g. unchanged), the deploy is skipped.
  *
- * @param {Object} options - Deployment options.
- * @param {CliConfig} options.config - The CLI configuration object.
- * @param {ListAssets} options.listAssets - A function to list existing files on the target.
- * @param {Function} [options.assertSourceDirExists] - Optional check to ensure source directory exists.
- * @param {Function} options.assertMemory - A function to ensure enough memory is available.
- * @param {UploadFile} options.uploadFile - A function responsible for uploading a single file.
- *
- * @returns {Promise<DeployResult>} An object containing the result of the deploy:
- *   - `skipped` if no files were found.
- *   - `deployed` and a list of uploaded files if the deploy succeeded.
+ * @param {Object} options
+ * @param {DeployParams} options.params - Deployment parameters (paths, config, etc.).
+ * @param {UploadIndividually | UploadWithBatch} options.upload - Upload strategy function.
+ *   Pass a function that either uploads files **with batch** (single init/commit)
+ *   or **individually** (per-file init/commit).
+ * @returns {Promise<DeployResult>}
+ *   - `{ result: 'skipped' }` when there are no files to upload.
+ *   - `{ result: 'deployed', files }` when the upload completes.
  */
-export declare const deploy: ({ uploadFile, ...rest }: DeployParams) => Promise<DeployResult>;
+export declare const deploy: ({ params, upload }: {
+    params: DeployParams;
+    upload: UploadIndividually | UploadWithBatch;
+}) => Promise<DeployResult>;
 /**
- * Prepares and uploads assets as part of a proposal-based workflow.
+ * Prepares and uploads assets through a proposal workflow.
+ *
+ * Steps:
+ * 1) Prepare the list of files to upload.
+ * 2) If no files are found, skip.
+ * 3) Upload using the selected strategy (batched or per-file).
+ * 4) Submit a proposal for the asset upgrade and, if `autoCommit` is true, apply it.
  *
- * This function:
- * 1. Prepares the list of files to be uploaded.
- * 2. If no files are found (i.e. nothing to upload), the process is skipped.
- * 3. If files exist, uploads them a proposal flow.
- * 4. Optionally commits - apply - the proposal if `autoCommit` is `true`.
+ * Notes:
+ * - Chunk uploading is the same across strategies; only init/commit batching differs.
+ * - Set `clearAssets` to remove existing assets before upload (proposal field).
  *
- * @param {Object} options - The deployment and proposal options.
- * @param {DeployParams} options.deploy - Deployment-related parameters (file system, memory check, upload function).
- * @param {Object} options.proposal - Proposal-related options.
- * @param {CdnParameters} options.proposal.cdn - Parameters for interacting with the CDN and governance.
- * @param {boolean} options.proposal.autoCommit - If `true`, automatically commits the proposal after submission.
- * @param {boolean} [options.proposal.clearAssets] - Whether to clear existing assets before upload (optional).
+ * @param {Object} options
+ * @param {Object} options.deploy
+ * @param {DeployParams} options.deploy.params - Deployment parameters.
+ * @param {UploadIndividually<UploadFileWithProposal> | UploadWithBatch<UploadFilesWithProposal>} options.deploy.upload
+ *   Upload strategy function used *within the proposal flow*.
+ * @param {Object} options.proposal
+ * @param {CdnParameters} options.proposal.cdn - Governance/CDN params.
+ * @param {boolean} options.proposal.autoCommit - Apply the proposal automatically after submission.
+ * @param {boolean} [options.proposal.clearAssets] - Clear existing assets before upload.
  *
- * @returns {Promise<DeployResultWithProposal>} The result of the deployment process:
- *   - `{result: 'skipped'}` if no files were found for upload.
- *   - `{result: 'submitted', files, proposalId}` if the upload and proposal submission succeeded.
- *   - `{result: 'deployed', files, proposalId}` if the upload and proposal was applied automatically committed.
+ * @returns {Promise<DeployResultWithProposal>}
+ *   - `{ result: 'skipped' }` when there are no files.
+ *   - `{ result: 'submitted', files, proposalId }` when proposed but not applied.
+ *   - `{ result: 'deployed', files, proposalId }` when proposed and auto-applied.
  */
-export declare const deployWithProposal: ({ deploy: { uploadFile, ...rest }, proposal: { clearAssets, ...restProposal } }: {
-    deploy: DeployParams<UploadFileWithProposal>;
+export declare const deployWithProposal: ({ deploy: { params, upload }, proposal: { clearAssets, ...restProposal } }: {
+    deploy: {
+        params: DeployParams;
+        upload: UploadIndividually<UploadFileWithProposal> | UploadWithBatch<UploadFilesWithProposal>;
+    };
     proposal: Pick<ProposeChangesParams, "cdn" | "autoCommit"> & {
         clearAssets?: boolean;
     };

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

@@ -4,12 +4,18 @@ import type { PublishSatelliteWasmParams } from '../types/publish';
 /**
  * Uploads a Satellite WASM file to the CDN as part of a proposal-based deployment.
  *
- * This function performs a memory check (if provided), packages the WASM file,
- * uploads it to the CDN, and submits a proposal for deployment.
- * Optionally, the proposal can be auto-committed if `autoCommit` is true.
+ * This function:
+ * 1. Optionally performs a memory check (via `assertMemory`).
+ * 2. Packages the WASM file into the required format.
+ * 3. Uploads the file(s) using the provided upload function — which may
+ *    perform a batched proposal flow or an individual file flow, depending
+ *    on the `upload` implementation.
+ * 4. Submits a proposal to deploy the uploaded Satellite WASM.
+ * 5. Optionally commits (applies) the proposal if `autoCommit` is `true`.
  *
  * @param {Object} options - The deployment and proposal configuration.
- * @param {PublishSatelliteWasmParams} options.deploy - Deployment parameters including the upload function, memory assertion, and file paths.
+ * @param {PublishSatelliteWasmParams} options.publish - Publication parameters including the upload function,
+ * memory assertion, and file paths.
  * @param {Object} options.proposal - Proposal options.
  * @param {CdnParameters} options.proposal.cdn - CDN and governance configuration.
  * @param {boolean} options.proposal.autoCommit - If `true`, the proposal is automatically committed after submission.
@@ -20,7 +26,7 @@ import type { PublishSatelliteWasmParams } from '../types/publish';
  * - `{ result: 'submitted', files, proposalId }` – Upload and proposal submission succeeded.
  * - `{ result: 'deployed', files, proposalId }` – Upload succeeded and proposal was auto-committed.
  */
-export declare const publishSatelliteWasmWithProposal: ({ publish: { assertMemory, filePath, fullPath, ...restDeploy }, proposal: { version, ...restProposal } }: {
+export declare const publishSatelliteWasmWithProposal: ({ publish: { assertMemory, filePath, fullPath, upload, ...restDeploy }, proposal: { version, ...restProposal } }: {
     publish: PublishSatelliteWasmParams;
     proposal: Pick<ProposeChangesParams, "cdn" | "autoCommit"> & {
         version: string;

package/dist/types/constants/deploy.constants.d.ts

@@ -1,8 +1,9 @@
+import type { Precompress } from '@junobuild/config';
 export declare const DEPLOY_DEFAULT_SOURCE = "build";
 export declare const DEPLOY_DEFAULT_IGNORE: never[];
 export declare const DEPLOY_DEFAULT_ENCODING: never[];
-export declare const DEPLOY_DEFAULT_GZIP = "**/*.+(css|js|mjs|html)";
+export declare const DEPLOY_DEFAULT_PRECOMPRESS: Required<Precompress>;
 export declare const IGNORE_OS_FILES: string[];
-export declare const UPLOAD_BATCH_SIZE = 20;
+export declare const UPLOAD_DEFAULT_BATCH_SIZE = 20;
 export declare const COLLECTION_DAPP = "#dapp";
 export declare const COLLECTION_CDN_RELEASES = "#_juno/releases";

package/dist/types/services/deploy.proposal.services.d.ts

@@ -1,11 +1,9 @@
-import type { COLLECTION_CDN_RELEASES, COLLECTION_DAPP } from '../constants/deploy.constants';
-import type { DeployParams, DeployResultWithProposal, FileAndPaths, UploadFileWithProposal } from '../types/deploy';
+import type { DeployResultWithProposal, UploadFilesWithProposal, UploadFileWithProposal, UploadIndividually, UploadWithBatch } from '../types/deploy';
 import type { ProposeChangesParams } from '../types/proposal';
-export declare const deployAndProposeChanges: ({ deploy: { uploadFile, files, sourceAbsolutePath, collection }, proposal: { proposalType, autoCommit, ...proposalRest } }: {
-    deploy: Pick<DeployParams<UploadFileWithProposal>, "uploadFile"> & {
-        files: FileAndPaths[];
-        sourceAbsolutePath: string;
-        collection: typeof COLLECTION_DAPP | typeof COLLECTION_CDN_RELEASES;
-    };
+import type { UploadFilesParams } from '../types/upload';
+export declare const deployAndProposeChanges: ({ deploy: { upload, files, sourceAbsolutePath, collection, batchSize }, proposal: { proposalType, autoCommit, ...proposalRest } }: {
+    deploy: {
+        upload: UploadIndividually<UploadFileWithProposal> | UploadWithBatch<UploadFilesWithProposal>;
+    } & UploadFilesParams;
     proposal: Omit<ProposeChangesParams, "executeChanges">;
 }) => Promise<DeployResultWithProposal>;

package/dist/types/services/upload/_upload.services.d.ts

@@ -0,0 +1,13 @@
+import type { FileAndPaths, FileDetails, UploadFileStorage } from '../../types/deploy';
+import type { UploadFilesParams } from '../../types/upload';
+export declare const prepareFileForUpload: ({ file, fullPath, collection, filePath, token, description }: {
+    file: FileDetails;
+    filePath: string;
+} & Pick<UploadFileStorage, "fullPath" | "collection" | "token" | "description">) => Promise<UploadFileStorage>;
+export type ExecuteUploadFiles = (params: {
+    groupFiles: FileAndPaths[];
+    step: 'alternate' | 'source';
+}) => Promise<void>;
+export declare const executeUploadFiles: ({ files, uploadFiles }: {
+    uploadFiles: ExecuteUploadFiles;
+} & Pick<UploadFilesParams, "files">) => Promise<void>;

package/dist/types/services/upload/upload.batch.services.d.ts

@@ -0,0 +1,5 @@
+import type { UploadFiles } from '../../types/deploy';
+import type { UploadFilesParams } from '../../types/upload';
+export declare const uploadFilesWithBatch: ({ uploadFiles, collection, ...rest }: {
+    uploadFiles: UploadFiles;
+} & UploadFilesParams) => Promise<void>;

package/dist/types/services/upload/upload.individual.services.d.ts

@@ -0,0 +1,5 @@
+import type { UploadFile } from '../../types/deploy';
+import type { UploadFilesParams } from '../../types/upload';
+export declare const uploadFilesIndividually: ({ uploadFile, collection, ...rest }: {
+    uploadFile: UploadFile;
+} & UploadFilesParams) => Promise<void>;

package/dist/types/services/upload.services.d.ts

@@ -1,8 +1,5 @@
-import { type COLLECTION_CDN_RELEASES, type COLLECTION_DAPP } from '../constants/deploy.constants';
-import type { FileAndPaths, UploadFile } from '../types/deploy';
-export declare const uploadFiles: ({ files: sourceFiles, uploadFile, sourceAbsolutePath, collection }: {
-    files: FileAndPaths[];
-    uploadFile: UploadFile;
-    sourceAbsolutePath: string;
-    collection: typeof COLLECTION_DAPP | typeof COLLECTION_CDN_RELEASES;
+import type { UploadIndividually, UploadWithBatch } from '../types/deploy';
+import type { UploadFilesParams } from '../types/upload';
+export declare const uploadFiles: ({ upload, files, ...rest }: UploadFilesParams & {
+    upload: UploadIndividually | UploadWithBatch;
 }) => Promise<void>;

package/dist/types/types/deploy.d.ts

@@ -1,5 +1,5 @@
 import type { CliConfig, EncodingType } from '@junobuild/config';
-import type { Asset } from '@junobuild/storage';
+import type { Asset, OnUploadProgress } from '@junobuild/storage';
 export type MimeType = string;
 export type FileExtension = string;
 export interface FileDetails {
@@ -33,6 +33,14 @@ export type UploadFileStorageWithProposal = UploadFileStorage & {
 };
 export type UploadFile = (params: UploadFileStorage) => Promise<void>;
 export type UploadFileWithProposal = (params: UploadFileStorageWithProposal) => Promise<void>;
+export interface UploadFilesStorageWithProposal {
+    files: UploadFileStorage[];
+    proposalId: bigint;
+}
+export type UploadFiles = (params: {
+    files: UploadFileStorage[];
+} & OnUploadProgress) => Promise<void>;
+export type UploadFilesWithProposal = (params: UploadFilesStorageWithProposal) => Promise<void>;
 export type DeployResult = {
     result: 'deployed';
     files: Pick<FileDetails, 'file'>[];
@@ -54,9 +62,15 @@ export interface PrepareDeployOptions {
     assertSourceDirExists?: (source: string) => void;
     includeAllFiles?: boolean;
 }
-export type DeployParams<T = UploadFile> = PrepareDeployOptions & {
+export type DeployParams = PrepareDeployOptions & {
     config: CliConfig;
     listAssets: ListAssets;
     assertMemory: () => Promise<void>;
-    uploadFile: T;
+    uploadBatchSize?: number;
 };
+export interface UploadIndividually<T = UploadFile> {
+    uploadFile: T;
+}
+export interface UploadWithBatch<T = UploadFiles> {
+    uploadFiles: T;
+}

package/dist/types/types/publish.d.ts

@@ -1,4 +1,6 @@
-import type { DeployParams, FilePaths, UploadFileWithProposal } from './deploy';
-export type PublishSatelliteWasmParams = Pick<DeployParams<UploadFileWithProposal>, 'assertMemory' | 'uploadFile'> & FilePaths & {
+import type { DeployParams, FilePaths, UploadFileWithProposal, UploadIndividually } from './deploy';
+export type PublishSatelliteWasmParams = {
+    upload: UploadIndividually<UploadFileWithProposal>;
+} & Pick<DeployParams, 'assertMemory'> & FilePaths & {
     sourceAbsolutePath: string;
 };

package/dist/types/types/upload.d.ts

@@ -0,0 +1,10 @@
+import type { OnUploadProgress } from '@junobuild/storage';
+import type { COLLECTION_CDN_RELEASES, COLLECTION_DAPP } from '../constants/deploy.constants';
+import type { FileAndPaths } from './deploy';
+export interface UploadFilesParams {
+    files: FileAndPaths[];
+    sourceAbsolutePath: string;
+    collection: typeof COLLECTION_DAPP | typeof COLLECTION_CDN_RELEASES;
+    batchSize: number;
+}
+export type UploadFilesParamsWithProgress = UploadFilesParams & Required<OnUploadProgress>;

package/dist/types/utils/compress.utils.d.ts

@@ -2,10 +2,14 @@ import type { SatelliteConfig } from '@junobuild/config';
 export declare const gunzipFile: ({ source }: {
     source: Buffer;
 }) => Promise<Buffer>;
-export declare const gzipFiles: ({ sourceFiles, gzip }: {
+export declare const compressFiles: ({ sourceFiles, precompress }: {
     sourceFiles: string[];
-} & Required<Pick<SatelliteConfig, "gzip">>) => Promise<string[]>;
-export declare const gzipFile: ({ source, destination }: {
+} & Required<Pick<SatelliteConfig, "precompress">>) => Promise<string[]>;
+export declare const gzipFile: (params: {
+    source: string;
+    destination?: string;
+}) => Promise<string>;
+export declare const brotliFile: (params: {
     source: string;
     destination?: string;
 }) => Promise<string>;

package/dist/types/utils/upload.utils.d.ts

@@ -0,0 +1,2 @@
+import type { FileAndPaths } from '../types/deploy';
+export declare const splitSourceFiles: (files: FileAndPaths[]) => [FileAndPaths[], FileAndPaths[]];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junobuild/cli-tools",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "A collection of tools for Juno CLIs and Plugins.",
   "author": "David Dal Busco (https://daviddalbusco.com)",
   "license": "MIT",
@@ -54,19 +54,19 @@
   "homepage": "https://juno.build",
   "peerDependencies": {
     "@dfinity/utils": "^2",
-    "@junobuild/cdn": "^1",
-    "@junobuild/config": "*",
-    "@junobuild/storage": "^1",
-    "esbuild": "^0.25.1"
+    "@junobuild/cdn": "^1.1.0",
+    "@junobuild/config": "^2",
+    "@junobuild/storage": "^1.1.0",
+    "esbuild": "^0.25.1",
+    "ora": "^8"
   },
   "dependencies": {
     "file-type": "^21.0.0",
-    "listr": "^0.14.3",
+    "listr2": "^9.0.1",
     "mime-types": "^3.0.1",
     "minimatch": "^10.0.3"
   },
   "devDependencies": {
-    "@types/listr": "^0.14.9",
     "@types/mime-types": "^3.0.1",
     "@types/minimatch": "^6.0.0"
   }