@uipath/project-packager 1.1.4

package/dist/src/node-project-packager-factory.d.ts

@@ -0,0 +1,22 @@
+import type { PackagerConfig } from "./models/packager-config.js";
+import { type IProjectPackager } from "./services/project-packager.js";
+/**
+ * Creates a ProjectPackager instance configured for Node.js usage.
+ *
+ * This is a convenience function that creates a NodeProjectPackagerFactory and calls createAsync.
+ *
+ * @param options - Configuration options for the ProjectPackager
+ * @returns Promise<IProjectPackager> - A fully configured ProjectPackager instance ready for use in Node.js.
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with default tools
+ * const packager = await createNodeProjectPackager();
+ *
+ * // With custom log handler
+ * const packager = await createNodeProjectPackager({
+ *   logHandler: (message) => console.log(message)
+ * });
+ * ```
+ */
+export declare function createNodeProjectPackager(options?: PackagerConfig): Promise<IProjectPackager>;

package/dist/src/node.d.ts

@@ -0,0 +1,32 @@
+import "./i18n/index.js";
+export type { IContextStorage, ITelemetryProvider, ITelemetryService, TelemetryContext, TelemetryProperties, } from "@uipath/telemetry/node";
+export { ConsoleTelemetryProvider, NodeContextStorage, TelemetryService, } from "@uipath/telemetry/node";
+export { BaseNodePackagerFactory } from "./base-node-packager-factory.js";
+export type { PackagerConfig } from "./models/packager-config.js";
+export type { PackageSigningInfo, ValidateOptions, } from "./models/packager-parameters.js";
+export { PackagerParameters, RulesConfigFileType, } from "./models/packager-parameters.js";
+export { ProjectBuildOptions } from "./models/project-build-options.js";
+export type { UiPathProject } from "./models/project-models.js";
+export { ProjectPackOptions } from "./models/project-pack-options.js";
+export { ProjectRestoreOptions } from "./models/project-restore-options.js";
+export { ProjectValidateOptions } from "./models/project-validate-options.js";
+export { createNodeProjectPackager } from "./node-project-packager-factory.js";
+export type { IPackService } from "./services/pack-service.js";
+export { PackService } from "./services/pack-service.js";
+export type { IPackageSignService } from "./services/package-sign-service.js";
+export { NodePackageSignService } from "./services/package-sign-service.js";
+export type { IPackagerParametersValidator } from "./services/packager-parameters-validator.js";
+export { PackagerParametersValidator } from "./services/packager-parameters-validator.js";
+export type { IProjectBuildOptionsValidator } from "./services/project-build-options-validator.js";
+export { ProjectBuildOptionsValidator } from "./services/project-build-options-validator.js";
+export type { IProjectLoader } from "./services/project-loader.js";
+export { ProjectLoader } from "./services/project-loader.js";
+export type { IProjectPackager, PackageStream, } from "./services/project-packager.js";
+export { ProjectPackager } from "./services/project-packager.js";
+export { type IProjectToolExecutor, ProjectToolExecutor, } from "./services/project-tool-executor.js";
+export type { IProjectValidateOptionsValidator } from "./services/project-validate-options-validator.js";
+export { ProjectValidateOptionsValidator } from "./services/project-validate-options-validator.js";
+export type { LogHandler } from "./services/tool-logger.js";
+export { setGlobalLogHandler, ToolLogger } from "./services/tool-logger.js";
+export { type IToolsFactory, ToolsFactory } from "./services/tools-factory.js";
+export { TelemetryNames } from "./telemetry-names.js";

package/dist/src/services/pack-service.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Interface for NuGet package operations
+ */
+export interface IPackService {
+    /**
+     * Sanitize a package ID to conform to NuGet standards
+     * @param packageId - The package ID to sanitize
+     * @returns The sanitized package ID
+     */
+    sanitizePackageId(packageId: string): string;
+}
+/**
+ * Service for NuGet package operations
+ */
+export declare class PackService implements IPackService {
+    private readonly disallowedCharsRegex;
+    private readonly spacesDotRegex;
+    private readonly dotDashRegex;
+    private readonly MaxPackageIdLength;
+    /**
+     * Sanitize a package ID to conform to NuGet standards
+     * @param packageId - The package ID to sanitize
+     * @returns The sanitized package ID
+     */
+    sanitizePackageId(packageId: string): string;
+}

package/dist/src/services/package-sign-service.d.ts

@@ -0,0 +1,22 @@
+import type { IToolLogger } from "@uipath/solutionpackager-tool-core";
+import { ToolResult } from "@uipath/solutionpackager-tool-core";
+/**
+ * Provides package signing operations with availability checks.
+ */
+export interface IPackageSignService {
+    /**
+     * Sign a NuGet package using dotnet nuget sign.
+     * @param packagePath - Path to the .nupkg file to sign
+     * @param certificatePath - Path to the PFX certificate file
+     * @param certificatePassword - Optional password for the certificate
+     * @param timestampServer - Optional RFC 3161 timestamp server URL
+     * @returns ToolResult indicating success or failure
+     */
+    signPackageAsync(packagePath: string, certificatePath: string, certificatePassword?: string, timestampServer?: string): Promise<ToolResult>;
+}
+export declare class NodePackageSignService implements IPackageSignService {
+    private readonly logger;
+    constructor(logger: IToolLogger);
+    signPackageAsync(packagePath: string, certificatePath: string, certificatePassword?: string, timestampServer?: string): Promise<ToolResult>;
+    private checkAvailable;
+}

package/dist/src/services/packager-parameters-validator.d.ts

@@ -0,0 +1,26 @@
+import { type IFileSystem, type IToolLogger, ToolResult } from "@uipath/solutionpackager-tool-core";
+import { type PackagerParameters, type ValidateOptions } from "../models/packager-parameters.js";
+/**
+ * Interface for a pack options validator
+ */
+export interface IPackagerParametersValidator<TOptions extends PackagerParameters> {
+    /**
+     * Validate pack options
+     * @param options Pack options to validate
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult indicating validation success or failure
+     */
+    validateAsync(options: TOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+}
+/**
+ * Base validator for packager parameters.
+ * Contains common validation logic shared by solution and project validators.
+ */
+export declare class PackagerParametersValidator<TOptions extends PackagerParameters> implements IPackagerParametersValidator<TOptions> {
+    protected readonly logger: IToolLogger;
+    protected readonly fileSystem: IFileSystem;
+    constructor(logger: IToolLogger, fileSystem: IFileSystem);
+    validateAsync(_options: TOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    protected validateDestinationPath(destinationPath: string): ToolResult;
+    protected validateGovernanceOptions(validateOptions: ValidateOptions): Promise<ToolResult>;
+}

package/dist/src/services/project-build-options-validator.d.ts

@@ -0,0 +1,14 @@
+import type { ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { ProjectBuildOptions } from "../models/project-build-options.js";
+import { type IPackagerParametersValidator, PackagerParametersValidator } from "./packager-parameters-validator.js";
+/**
+ * Interface for the project build options validator
+ */
+export type IProjectBuildOptionsValidator = IPackagerParametersValidator<ProjectBuildOptions>;
+/**
+ * Validator for project build options.
+ * Validates governance options required for build operations.
+ */
+export declare class ProjectBuildOptionsValidator extends PackagerParametersValidator<ProjectBuildOptions> implements IProjectBuildOptionsValidator {
+    validateAsync(options: ProjectBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+}

package/dist/src/services/project-loader.d.ts

@@ -0,0 +1,24 @@
+import { type IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { LoadedUiProject } from "../models/project-models.js";
+/**
+ * Interface for loading project information from the file system
+ */
+export interface IProjectLoader {
+    /**
+     * Load project information from a directory path.
+     * Searches for project.uiproj first, falls back to webAppManifest.json.
+     * @param projectPath Path to the project directory
+     * @returns Loaded project information
+     * @throws Error if neither project.uiproj nor webAppManifest.json is found
+     */
+    loadProject(projectPath: string): Promise<LoadedUiProject>;
+}
+export declare class ProjectLoader implements IProjectLoader {
+    private readonly fileSystem;
+    static readonly ProjectFileName = "project.uiproj";
+    static readonly WebAppManifestFileName = "webAppManifest.json";
+    constructor(fileSystem: IFileSystem);
+    loadProject(projectPath: string): Promise<LoadedUiProject>;
+    private loadFromProjectFile;
+    private loadFromWebAppManifest;
+}

package/dist/src/services/project-pack-options-builder.d.ts

@@ -0,0 +1,19 @@
+import type { IFileSystem, IProjectPackOptions } from "@uipath/solutionpackager-tool-core";
+import type { LoadedUiProject } from "../models/project-models.js";
+import type { ProjectPackOptions } from "../models/project-pack-options.js";
+import type { IPackService } from "./pack-service.js";
+/**
+ * Interface for building project pack options
+ */
+export interface IProjectPackOptionsBuilder {
+    /**
+     * Build project pack options from project parameters and loaded project info
+     */
+    buildProjectPackOptions(parameters: ProjectPackOptions, project: LoadedUiProject): Promise<IProjectPackOptions>;
+}
+export declare class ProjectPackOptionsBuilder implements IProjectPackOptionsBuilder {
+    private readonly packService;
+    private readonly fileSystem;
+    constructor(packService: IPackService, fileSystem: IFileSystem);
+    buildProjectPackOptions(parameters: ProjectPackOptions, project: LoadedUiProject): Promise<IProjectPackOptions>;
+}

package/dist/src/services/project-pack-options-validator.d.ts

@@ -0,0 +1,15 @@
+import type { ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { ProjectPackOptions } from "../models/project-pack-options.js";
+import type { IPackagerParametersValidator } from "./packager-parameters-validator.js";
+import { ProjectBuildOptionsValidator } from "./project-build-options-validator.js";
+/**
+ * Interface for the project pack options validator
+ */
+export type IProjectPackOptionsValidator = IPackagerParametersValidator<ProjectPackOptions>;
+/**
+ * Validator for project pack options.
+ * Validates destination path and governance options required for pack operations.
+ */
+export declare class ProjectPackOptionsValidator extends ProjectBuildOptionsValidator implements IProjectPackOptionsValidator {
+    validateAsync(options: ProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+}

package/dist/src/services/project-packager.d.ts

@@ -0,0 +1,146 @@
+import { type IFileSystem, ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { ITelemetryService } from "@uipath/telemetry";
+import type { ProjectBuildOptions } from "../models/project-build-options.js";
+import type { ProjectPackOptions } from "../models/project-pack-options.js";
+import type { ProjectRestoreOptions } from "../models/project-restore-options.js";
+import type { ProjectValidateOptions } from "../models/project-validate-options.js";
+import type { IPackageSignService } from "./package-sign-service.js";
+/**
+ * Package stream containing package data
+ */
+export interface PackageStream {
+    /** Name of the package file */
+    name: string;
+    /** Package file data */
+    data: Uint8Array;
+}
+/**
+ * Interface for the ProjectPackager component.
+ * Provides methods to setup and pack individual UiPath projects.
+ */
+export interface IProjectPackager {
+    /**
+     * File system instance
+     */
+    readonly fileSystem: IFileSystem;
+    /**
+     * Check if the project can be packed by verifying the project type has a registered tool.
+     * @param projectPath Path to the project folder
+     * @returns True if the project type has a registered tool factory
+     */
+    canPackProjectAsync(projectPath: string): Promise<boolean>;
+    /**
+     * Setup the temporary storage.
+     * @param input The project folder as a zip Uint8Array (extracts to temp folder) or a path string (uses as-is)
+     * @param operationId Optional operation ID for telemetry correlation
+     * @returns The path to the project folder
+     */
+    setupAsync(input: Uint8Array | string, operationId?: string): Promise<string>;
+    /**
+     * Restore project dependencies.
+     * @param options Project options containing input path and configuration
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult indicating success or failure
+     */
+    restoreProjectAsync(options: ProjectRestoreOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Analyze (validate) a project.
+     * @param options Project options containing input path and configuration
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult indicating success or failure
+     */
+    validateProjectAsync(options: ProjectValidateOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Build a project.
+     * @param options Project options containing input path, output path, and configuration
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult indicating success or failure
+     */
+    buildProjectAsync(options: ProjectBuildOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Pack a project using the provided options.
+     * @param options Project pack options containing all parameters
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult with the paths to the created packages
+     */
+    packProjectAsync(options: ProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Convert a successful ToolResult to a list of package streams.
+     * @param result The ToolResult to convert
+     * @returns A promise that resolves to an array of PackageStream objects
+     * @throws Error if the result is not successful or if any package file cannot be read
+     */
+    getPackageStreamsAsync(result: ToolResult): Promise<PackageStream[]>;
+}
+export declare class ProjectPackager implements IProjectPackager {
+    readonly fileSystem: IFileSystem;
+    private readonly telemetryService;
+    private readonly packageSignService?;
+    private readonly repository;
+    private readonly temporaryStorage;
+    private readonly zipService;
+    private readonly logger;
+    private readonly optionsBuilder;
+    private readonly toolsFactory;
+    private readonly projectExecutor;
+    private readonly projectLoader;
+    private readonly validateOptionsValidator;
+    private readonly buildOptionsValidator;
+    private readonly packOptionsValidator;
+    private readonly nugetPackager;
+    constructor(fileSystem: IFileSystem, telemetryService: ITelemetryService, packageSignService?: IPackageSignService | undefined);
+    /**
+     * Check if the project can be packed by verifying the project type has a registered tool.
+     * @param projectPath Path to the project folder
+     * @returns True if the project type has a registered tool factory
+     */
+    canPackProjectAsync(projectPath: string): Promise<boolean>;
+    /**
+     * Setup the temporary storage.
+     * @param input The project folder as a zip Uint8Array (extracts to temp folder) or a path string (uses as-is)
+     * @param operationId Optional operation ID for telemetry correlation
+     * @returns The path to the project folder
+     */
+    setupAsync(input: Uint8Array | string, operationId?: string): Promise<string>;
+    /**
+     * Restore project dependencies.
+     */
+    restoreProjectAsync(options: ProjectRestoreOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Validate a project.
+     */
+    validateProjectAsync(options: ProjectValidateOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Build a project.
+     */
+    buildProjectAsync(options: ProjectBuildOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Pack a project using the provided options.
+     * @param options Project pack options containing all parameters
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult with the paths to the created packages
+     */
+    packProjectAsync(options: ProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Convert a successful ToolResult to a list of package streams.
+     * @param result The ToolResult to convert
+     * @returns A promise that resolves to an array of PackageStream objects
+     * @throws Error if the result is not successful or if any package file cannot be read
+     */
+    getPackageStreamsAsync(result: ToolResult): Promise<PackageStream[]>;
+    /**
+     * Common logic for restore, analyze, and build operations:
+     * validates options, loads the project, executes the operation, and handles errors.
+     */
+    private executeProjectOperationAsync;
+    /**
+     * Copy packages from the output path to the destination path.
+     * Handles file paths, directories with .nupkg files, and directories with
+     * unpacked NuGet content (e.g., content/, lib/ folders from WorkflowCompiler).
+     * @param packagePaths Paths to the package files or directories
+     * @param destinationPath Destination directory
+     * @param packageInfo NuGet package info for creating .nupkg from unpacked content
+     * @returns Paths to the copied package files
+     */
+    private copyPackagesToDestination;
+}

package/dist/src/services/project-tool-executor.d.ts

@@ -0,0 +1,36 @@
+import { type IProjectBuildOptions, type IProjectPackOptions, type IProjectRestoreOptions, type IProjectValidateOptions, type ProjectOperationContext, ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { ITelemetryService } from "@uipath/telemetry";
+import type { PackageSigningInfo } from "../models/packager-parameters.js";
+import type { UiPathProject } from "../models/project-models.js";
+import type { IPackageSignService } from "./package-sign-service.js";
+import type { IToolsFactory } from "./tools-factory.js";
+/**
+ * Interface for executing project tool operations
+ */
+export interface IProjectToolExecutor {
+    restoreAsync(options: IProjectRestoreOptions, project: UiPathProject, context?: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    validateAsync(options: IProjectValidateOptions, project: UiPathProject, context?: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    buildAsync(options: IProjectBuildOptions, project: UiPathProject, context?: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    packAsync(options: IProjectPackOptions, project: UiPathProject, context?: ProjectOperationContext, signingInfo?: PackageSigningInfo, cancellationToken?: AbortSignal): Promise<ToolResult>;
+}
+export declare class ProjectToolExecutor implements IProjectToolExecutor {
+    private readonly toolsFactory;
+    private readonly telemetry;
+    private readonly packageSignService?;
+    constructor(toolsFactory: IToolsFactory, telemetry: ITelemetryService, packageSignService?: IPackageSignService | undefined);
+    restoreAsync(options: IProjectRestoreOptions, project: UiPathProject, context?: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    validateAsync(options: IProjectValidateOptions, project: UiPathProject, context?: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    buildAsync(options: IProjectBuildOptions, project: UiPathProject, context?: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    packAsync(options: IProjectPackOptions, project: UiPathProject, context?: ProjectOperationContext, signingInfo?: PackageSigningInfo, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Execute an operation on a project tool with proper creation and disposal.
+     */
+    private executeToolOperationAsync;
+    /**
+     * Sign all packages using the package sign service.
+     * @param packages - Array of package paths to sign
+     * @param signingInfo - Signing configuration
+     * @returns ToolResult indicating success or failure
+     */
+    private signPackagesAsync;
+}

package/dist/src/services/project-validate-options-validator.d.ts

@@ -0,0 +1,14 @@
+import type { ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { ProjectValidateOptions } from "../models/project-validate-options.js";
+import { type IPackagerParametersValidator, PackagerParametersValidator } from "./packager-parameters-validator.js";
+/**
+ * Interface for the project validate options validator
+ */
+export type IProjectValidateOptionsValidator = IPackagerParametersValidator<ProjectValidateOptions>;
+/**
+ * Validator for project validate options.
+ * Validates governance options required for validate/analyze operations.
+ */
+export declare class ProjectValidateOptionsValidator extends PackagerParametersValidator<ProjectValidateOptions> implements IProjectValidateOptionsValidator {
+    validateAsync(options: ProjectValidateOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+}

package/dist/src/services/tool-logger.d.ts

@@ -0,0 +1,26 @@
+import { type IToolLogger, LogLevel, LogMessage, type LogOptions } from "@uipath/solutionpackager-tool-core";
+/**
+ * Callback type for handling log messages
+ * This is an implementation detail of ToolLogger
+ */
+export type LogHandler = (logMessage: LogMessage) => void;
+/**
+ * Set the global log handler for all ToolLogger instances that don't specify one
+ */
+export declare function setGlobalLogHandler(handler: LogHandler): void;
+/**
+ * Logger implementation for creating and outputting LogMessage instances
+ * with consistent source and sourceTarget
+ */
+export declare class ToolLogger implements IToolLogger {
+    private readonly source;
+    private readonly sourceTarget;
+    constructor(source: string, sourceTarget: string);
+    debug(message: string, options?: LogOptions): void;
+    info(message: string, options?: LogOptions): void;
+    warn(message: string, options?: LogOptions): void;
+    error(message: string, options?: LogOptions): void;
+    progress(message: string, options?: LogOptions): void;
+    log(message: string, logLevel: LogLevel, options?: LogOptions): void;
+    logMessage(message: LogMessage): void;
+}

package/dist/src/services/tools-factory.d.ts

@@ -0,0 +1,29 @@
+import type { IFileSystem, IToolsFactoryRepository, ProjectOperationContext, ProjectTool, SolutionTool } from "@uipath/solutionpackager-tool-core";
+import type { UiPathProject } from "../models/project-models.js";
+/**
+ * Factory interface for creating solution and project tools
+ */
+export interface IToolsFactory {
+    /**
+     * Create a solution tool for the specified solution
+     * @throws Error if no factory is registered
+     */
+    createSolutionToolAsync(solutionName: string): Promise<SolutionTool>;
+    /**
+     * Create a project tool for the specified project
+     * @param project - The project to create a tool for
+     * @param context - Optional operation context with id and sibling project info
+     * @throws Error if no factory is found for the project type
+     */
+    createProjectToolAsync(project: UiPathProject, context?: ProjectOperationContext): Promise<ProjectTool>;
+}
+/**
+ * Factory for creating solution and project tools
+ */
+export declare class ToolsFactory implements IToolsFactory {
+    private readonly repository;
+    private readonly fileSystem;
+    constructor(repository: IToolsFactoryRepository, fileSystem: IFileSystem);
+    createSolutionToolAsync(solutionName: string): Promise<SolutionTool>;
+    createProjectToolAsync(project: UiPathProject, context?: ProjectOperationContext): Promise<ProjectTool>;
+}

package/dist/src/telemetry-names.d.ts

@@ -0,0 +1,11 @@
+export declare enum TelemetryNames {
+    ProjectToolPack = "ProjectPackager.Tool.Pack",
+    ProjectToolRestore = "ProjectPackager.Tool.Restore",
+    ProjectToolValidate = "ProjectPackager.Tool.Validate",
+    ProjectToolBuild = "ProjectPackager.Tool.Build",
+    ProjectPackagerPack = "ProjectPackager.Pack",
+    ProjectPackagerRestore = "ProjectPackager.Restore",
+    ProjectPackagerValidate = "ProjectPackager.Validate",
+    ProjectPackagerBuild = "ProjectPackager.Build",
+    ProjectPackagerProjectLoaded = "ProjectPackager.ProjectLoaded"
+}

package/dist/tests/pack-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/project-loader.test.d.ts

@@ -0,0 +1 @@
+import "../src/i18n/index.js";

package/dist/tests/project-packager-e2e.test.d.ts

@@ -0,0 +1,7 @@
+import "@uipath/tool-connector";
+import "@uipath/tool-workflowcompiler";
+import "@uipath/tool-apiworkflow";
+import "@uipath/tool-flow";
+import "@uipath/tool-agent";
+import "@uipath/tool-webapp";
+import "@uipath/resource-builder-tool";

package/dist/tests/project-packager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/project-tool-executor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/tools-factory-repository.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@uipath/project-packager",
+    "version": "1.1.4",
+    "description": "UiPath Project Packager - core library for packing individual UiPath projects",
+    "type": "module",
+    "main": "./dist/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/src/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./node": {
+            "types": "./dist/src/node.d.ts",
+            "default": "./dist/node.js"
+        }
+    },
+    "types": "./dist/src/index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/UiPath/Studio.Common.git",
+        "directory": "packager/uipath-projectpackager"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "rslib build",
+        "clean": "rimraf dist",
+        "test": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        "prepack": "bun run build",
+        "publish:dry": "bun publish --dry-run",
+        "publish:gh": "bun publish",
+        "version:patch": "bun version patch --no-git-tag-version",
+        "version:minor": "bun version minor --no-git-tag-version",
+        "version:major": "bun version major --no-git-tag-version",
+        "lint": "biome check ."
+    },
+    "dependencies": {
+        "@uipath/filesystem": "^0.0.5",
+        "@uipath/solutionpackager-tool-core": "^0.0.26",
+        "@uipath/telemetry": "^0.0.4"
+    },
+    "peerDependencies": {
+        "fflate": "^0.8.2"
+    },
+    "devDependencies": {
+        "@rslib/core": "^0.20.0",
+        "@types/node": "^25.5.0",
+        "@uipath/resource-builder-tool": "^2025.11.0-alpha2430-2948",
+        "@uipath/tool-agent": "1.0.0",
+        "@uipath/tool-apiworkflow": "*",
+        "@uipath/tool-connector": "*",
+        "@uipath/tool-flow": "*",
+        "@uipath/tool-webapp": "1.0.0",
+        "@uipath/tool-workflowcompiler": "*",
+        "@vitest/coverage-v8": "^4.0.14",
+        "jsdom": "^29.0.0",
+        "typescript": "^5.9.3",
+        "vite-tsconfig-paths": "^6.1.1",
+        "vitest": "^4.0.14"
+    }
+}