@uipath/solutionpackager-tool-core 0.0.26

package/dist/models/project-options.d.ts

@@ -0,0 +1,126 @@
+import type { NugetPackageInfo } from "./nuget-package-info.js";
+/**
+ * Rules configuration file type enum
+ */
+export declare enum RulesConfigFileType {
+    Default = "Default",
+    AutomationOps = "AutomationOps",
+    Studio = "Studio"
+}
+/**
+ * Project options
+ */
+export interface IProjectOptions {
+    /**
+     * Path to the project folder.
+     */
+    projectPath: string;
+    /**
+     * Whether to exclude configured sources
+     */
+    excludeConfiguredSources: boolean;
+    /**
+     * Path to NuGet sources configuration file
+     */
+    nuGetSourcesConfigPath?: string;
+    /**
+     * Log level for the operation
+     */
+    logLevel?: string;
+}
+/**
+ * Project restore options
+ */
+export interface IProjectRestoreOptions extends IProjectOptions {
+    /**
+     * Output directory path
+     */
+    outputPath?: string;
+}
+/**
+ * Project validate options
+ */
+export interface IProjectValidateOptions extends IProjectOptions {
+    /**
+     * Whether to skip analysis
+     */
+    skipAnalyze: boolean;
+    /**
+     * Default severity level
+     */
+    defaultSeverity?: string;
+    /**
+     * Path to detailed log file
+     */
+    detailedLogPath?: string;
+    /**
+     * Path to policy file
+     */
+    policyFilePath?: string;
+    /**
+     * Policy file type
+     */
+    policyFileType?: RulesConfigFileType;
+}
+/**
+ * Project build options
+ */
+export interface IProjectBuildOptions extends IProjectOptions {
+    /**
+     * Whether to skip analysis
+     */
+    skipAnalyze: boolean;
+    /**
+     * Whether to skip validation
+     */
+    skipValidate: boolean;
+    /**
+     * Project storage identifier
+     */
+    projectStorageId?: string;
+    /**
+     * Path to detailed log file
+     */
+    detailedLogPath?: string;
+    /**
+     * Path to policy file
+     */
+    policyFilePath?: string;
+    /**
+     * Policy file type
+     */
+    policyFileType?: string;
+    /**
+     * Output directory path
+     */
+    outputPath: string;
+    /**
+     * Output type
+     */
+    outputType?: string;
+    /**
+     * Project type
+     */
+    projectType: string;
+}
+/**
+ * Project pack options
+ */
+export interface IProjectPackOptions extends IProjectBuildOptions {
+    /**
+     * NuGet package information
+     */
+    package: NugetPackageInfo;
+    /**
+     * Whether to skip dependency optimization
+     */
+    skipDependencyOptimization: boolean;
+    /**
+     * Whether to include sources
+     */
+    includeSources: boolean;
+    /**
+     * Whether to split packages
+     */
+    splitPackages: boolean;
+}

package/dist/models/project-options.js

@@ -0,0 +1,7 @@
+var project_options_RulesConfigFileType = /*#__PURE__*/ function(RulesConfigFileType) {
+    RulesConfigFileType["Default"] = "Default";
+    RulesConfigFileType["AutomationOps"] = "AutomationOps";
+    RulesConfigFileType["Studio"] = "Studio";
+    return RulesConfigFileType;
+}({});
+export { project_options_RulesConfigFileType as RulesConfigFileType };

package/dist/models/project-type.d.ts

@@ -0,0 +1,21 @@
+/**
+ * UiPath project type enum
+ */
+export declare enum ProjectTypes {
+    Agent = "Agent",
+    Api = "Api",
+    Connector = "Connector",
+    CaseManagement = "CaseManagement",
+    Flow = "Flow",
+    Function = "Function",
+    ProcessOrchestration = "ProcessOrchestration",
+    Process = "Process",
+    Library = "Library",
+    WebApp = "WebApp",
+    Tests = "Tests",
+    AppV2 = "AppV2"
+}
+/**
+ * UiPath project types (extensible with custom strings)
+ */
+export type ProjectType = ProjectTypes | string;

package/dist/models/project-type.js

@@ -0,0 +1,16 @@
+var project_type_ProjectTypes = /*#__PURE__*/ function(ProjectTypes) {
+    ProjectTypes["Agent"] = "Agent";
+    ProjectTypes["Api"] = "Api";
+    ProjectTypes["Connector"] = "Connector";
+    ProjectTypes["CaseManagement"] = "CaseManagement";
+    ProjectTypes["Flow"] = "Flow";
+    ProjectTypes["Function"] = "Function";
+    ProjectTypes["ProcessOrchestration"] = "ProcessOrchestration";
+    ProjectTypes["Process"] = "Process";
+    ProjectTypes["Library"] = "Library";
+    ProjectTypes["WebApp"] = "WebApp";
+    ProjectTypes["Tests"] = "Tests";
+    ProjectTypes["AppV2"] = "AppV2";
+    return ProjectTypes;
+}({});
+export { project_type_ProjectTypes as ProjectTypes };

package/dist/models/solution-options.d.ts

@@ -0,0 +1,72 @@
+import type { BuildConfiguration } from "./build-configuration.js";
+import type { ConnectionInfo } from "./connection-info.js";
+import type { PackageInfo } from "./package-info.js";
+/**
+ * Solution options
+ */
+export interface ISolutionOptions {
+    /**
+     * Path to the solution file
+     */
+    solutionFilePath: string;
+}
+/**
+ * Solution restore options
+ */
+export interface ISolutionRestoreOptions extends ISolutionOptions {
+    /**
+     * Output directory path
+     */
+    outputPath: string;
+    /**
+     * Build configuration (Debug or Release)
+     */
+    configuration: BuildConfiguration;
+    /**
+     * Projects to build
+     */
+    projectsToBuild: string[];
+    /**
+     * Connection information for restore
+     */
+    connection?: ConnectionInfo;
+}
+/**
+ * Solution validate options
+ */
+export interface ISolutionValidateOptions extends ISolutionOptions {
+    /**
+     * Package version to validate
+     */
+    packageVersion?: string;
+}
+/**
+ * Solution build options
+ */
+export interface ISolutionBuildOptions extends ISolutionRestoreOptions {
+    /**
+     * Output directory path
+     */
+    outputPath: string;
+    /**
+     * Build configuration (Debug or Release)
+     */
+    configuration: BuildConfiguration;
+    /**
+     * Projects to build
+     */
+    projectsToBuild: string[];
+    /**
+     * Package information
+     */
+    package: PackageInfo;
+    /**
+     * Publish identifier
+     */
+    publishId?: string;
+}
+/**
+ * Solution pack options
+ */
+export interface ISolutionPackOptions extends ISolutionBuildOptions {
+}

package/dist/models/target-frameworks.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Target framework for UiPath packages
+ */
+export declare enum TargetFramework {
+    Portable = "Portable",
+    Windows = "Windows"
+}

package/dist/models/target-frameworks.js

@@ -0,0 +1,6 @@
+var target_frameworks_TargetFramework = /*#__PURE__*/ function(TargetFramework) {
+    TargetFramework["Portable"] = "Portable";
+    TargetFramework["Windows"] = "Windows";
+    return TargetFramework;
+}({});
+export { target_frameworks_TargetFramework as TargetFramework };

package/dist/models/tool-error-code.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tool error code enum
+ */
+export declare enum ToolErrorCodes {
+    Success = "SUCCESS",
+    InternalError = "INTERNAL_ERROR",
+    Canceled = "CANCELED"
+}
+/**
+ * Base tool error codes (extensible with custom strings)
+ * Tools can extend this type with their own error codes:
+ *
+ * @example
+ * ```typescript
+ * export type MyToolErrorCode = ToolErrorCode | 'COMPILATION_FAILED' | 'VALIDATION_ERROR';
+ * ```
+ */
+export type ToolErrorCode = ToolErrorCodes | string;

package/dist/models/tool-error-code.js

@@ -0,0 +1,7 @@
+var tool_error_code_ToolErrorCodes = /*#__PURE__*/ function(ToolErrorCodes) {
+    ToolErrorCodes["Success"] = "SUCCESS";
+    ToolErrorCodes["InternalError"] = "INTERNAL_ERROR";
+    ToolErrorCodes["Canceled"] = "CANCELED";
+    return ToolErrorCodes;
+}({});
+export { tool_error_code_ToolErrorCodes as ToolErrorCodes };

package/dist/models/tool-result.d.ts

@@ -0,0 +1,31 @@
+import type { ToolErrorCode } from "./tool-error-code.js";
+/**
+ * Tool execution result
+ */
+export declare class ToolResult {
+    /**
+     * Error code indicating the result status
+     */
+    errorCode: ToolErrorCode;
+    /**
+     * Optional message
+     */
+    message?: string;
+    /**
+     * List of packages produced
+     */
+    packages: string[];
+    constructor(errorCode: ToolErrorCode, message?: string, packages?: string[]);
+    /**
+     * Indicates whether the result represents a successful operation
+     */
+    get isSuccess(): boolean;
+    /**
+     * Create a success result
+     */
+    static success(): ToolResult;
+    /**
+     * Create an error result
+     */
+    static error(errorCode: ToolErrorCode, message?: string): ToolResult;
+}

package/dist/models/tool-result.js

@@ -0,0 +1,21 @@
+import { ToolErrorCodes } from "./tool-error-code.js";
+class ToolResult {
+    errorCode;
+    message;
+    packages;
+    constructor(errorCode, message, packages = []){
+        this.errorCode = errorCode;
+        this.message = message;
+        this.packages = packages;
+    }
+    get isSuccess() {
+        return this.errorCode === ToolErrorCodes.Success;
+    }
+    static success() {
+        return new ToolResult(ToolErrorCodes.Success);
+    }
+    static error(errorCode, message) {
+        return new ToolResult(errorCode, message);
+    }
+}
+export { ToolResult };

package/dist/models/uipath-project.d.ts

@@ -0,0 +1,26 @@
+import type { ProjectType } from "./project-type.js";
+/**
+ * Represents a UiPath project within a solution .uipx file
+ */
+export interface UiPathProject {
+    /**
+     * The type of project (Api, Library, Process, etc.)
+     */
+    Type: ProjectType;
+    /**
+     * Relative path to the project file
+     */
+    ProjectRelativePath: string;
+    /**
+     * Unique identifier for the project
+     */
+    Id: string;
+    /**
+     * Absolute path to the project folder - to be set after loading the solution, not present in the .uipx file
+     */
+    ProjectPath?: string;
+    /**
+     * Storage identifier for the project - to be set after loading the solution, not present in the .uipx file
+     */
+    StorageId?: string;
+}

package/dist/models/uipath-solution.d.ts

@@ -0,0 +1,14 @@
+import type { UiPathProject } from "./uipath-project.js";
+/**
+ * Represents a UiPath solution containing multiple projects
+ */
+export interface UiPathSolution {
+    /**
+     * Unique identifier for the solution
+     */
+    SolutionId: string;
+    /**
+     * Array of projects contained in this solution
+     */
+    Projects: UiPathProject[];
+}

package/dist/package-descriptor/entry-points-file-model.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Entry point information
+ */
+export interface EntryPointModel {
+    /**
+     * Path to the entry point file
+     */
+    filePath: string;
+    /**
+     * Unique path identifier
+     */
+    uniqueId?: string;
+    /**
+     * Display name
+     */
+    displayName?: string;
+}
+/**
+ * Model for entrypoints.json file
+ */
+export interface EntryPointsFileModel {
+    /**
+     * List of entry points
+     */
+    entryPoints: EntryPointModel[];
+}

package/dist/package-descriptor/index.d.ts

@@ -0,0 +1,5 @@
+export type { EntryPointModel, EntryPointsFileModel, } from "./entry-points-file-model.js";
+export type { OperateFileModel, RuntimeOptionsModel, } from "./operate-file-model.js";
+export type { PackageDescriptorFileModel } from "./package-descriptor-file-model.js";
+export type { BindingsVersion, ProjectBindingsFileModel, PropertyBinding, ResourceBinding, } from "./project-bindings-file-model.js";
+export { createDefaultBindingsVersion } from "./project-bindings-file-model.js";

package/dist/package-descriptor/index.js

@@ -0,0 +1 @@
+export { createDefaultBindingsVersion } from "./project-bindings-file-model.js";

package/dist/package-descriptor/operate-file-model.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Runtime options for the operate file
+ */
+export interface RuntimeOptionsModel {
+    /**
+     * Whether the process requires user interaction
+     */
+    requiresUserInteraction: boolean;
+    /**
+     * Whether the process is attended
+     */
+    isAttended: boolean;
+}
+/**
+ * Model for operate.json file
+ */
+export interface OperateFileModel {
+    /**
+     * Project identifier
+     */
+    projectId: string;
+    /**
+     * Main entry point file path
+     */
+    main: string;
+    /**
+     * Content type (project type)
+     */
+    contentType: string;
+    /**
+     * Target framework
+     */
+    targetFramework: string;
+    /**
+     * Runtime options
+     */
+    runtimeOptions: RuntimeOptionsModel;
+}

package/dist/package-descriptor/package-descriptor-file-model.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Model for package-descriptor.json file
+ * Maps file identifiers to their relative paths
+ */
+export interface PackageDescriptorFileModel {
+    /**
+     * Map of file identifiers to relative paths
+     * Key: file identifier (e.g., 'operate.json', 'entrypoints.json', 'bindings')
+     * Value: relative path to the file from the package root
+     */
+    files: Record<string, string>;
+}

package/dist/package-descriptor/project-bindings-file-model.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Version information for bindings file
+ */
+export interface BindingsVersion {
+    major: number;
+    minor: number;
+}
+/**
+ * Property binding for resource values
+ */
+export interface PropertyBinding {
+    /**
+     * Default value for the property
+     */
+    defaultValue?: string;
+    /**
+     * Whether the value is an expression
+     */
+    isExpression: boolean;
+    /**
+     * Display name for the property
+     */
+    displayName?: string;
+    /**
+     * Description of the property
+     */
+    description?: string;
+}
+/**
+ * Resource binding definition
+ */
+export interface ResourceBinding {
+    /**
+     * Resource type/name
+     */
+    resource?: string;
+    /**
+     * Resource key
+     */
+    key?: string;
+    /**
+     * Unique identifier for the binding
+     */
+    id?: string;
+    /**
+     * Purpose of the resource binding
+     */
+    purpose?: string;
+    /**
+     * Description of the resource binding
+     */
+    description?: string;
+    /**
+     * Value properties - keys are contract names
+     */
+    value?: Record<string, PropertyBinding>;
+    /**
+     * Metadata properties
+     */
+    metadata?: Record<string, PropertyBinding>;
+    /**
+     * Path of the workflow where this resource binding is referenced
+     */
+    workflowRelativePath?: string;
+}
+/**
+ * Model for bindings-v2.json file (project bindings)
+ */
+export interface ProjectBindingsFileModel {
+    /**
+     * Version of the bindings format (default: 2.0)
+     */
+    version: BindingsVersion;
+    /**
+     * List of resource bindings
+     */
+    resources?: ResourceBinding[];
+}
+/**
+ * Create default bindings version (2.0)
+ */
+export declare function createDefaultBindingsVersion(): BindingsVersion;

package/dist/package-descriptor/project-bindings-file-model.js

@@ -0,0 +1,7 @@
+function createDefaultBindingsVersion() {
+    return {
+        major: 2,
+        minor: 0
+    };
+}
+export { createDefaultBindingsVersion };

package/dist/services/index.d.ts

@@ -0,0 +1,10 @@
+export type { INugetPackager, NugetPackagerResult } from "./nuget-packager.js";
+export { NugetPackager } from "./nuget-packager.js";
+export type { ProjectOperationContext } from "./project-operation-context.js";
+export { ProjectTool } from "./project-tool.js";
+export type { IProjectToolFactory } from "./project-tool-factory.js";
+export { SolutionTool } from "./solution-tool.js";
+export type { ISolutionToolFactory } from "./solution-tool-factory.js";
+export type { IToolLogger, LogOptions } from "./tool-logger.js";
+export type { IToolsFactoryRepository, IToolsFactoryRepositoryConfigurator, } from "./tools-factory-repository.js";
+export { ToolsFactoryRepository, toolsFactoryRepository, } from "./tools-factory-repository.js";

package/dist/services/index.js

@@ -0,0 +1,4 @@
+export { NugetPackager } from "./nuget-packager.js";
+export { ProjectTool } from "./project-tool.js";
+export { SolutionTool } from "./solution-tool.js";
+export { ToolsFactoryRepository, toolsFactoryRepository } from "./tools-factory-repository.js";

package/dist/services/nuget-packager.d.ts

@@ -0,0 +1,39 @@
+import type { IFileSystem } from "../filesystem/file-system.js";
+import type { NugetPackageInfo } from "../models/nuget-package-info.js";
+/**
+ * Result of a NuGet pack operation
+ */
+export interface NugetPackagerResult {
+    /**
+     * Full path to the created .nupkg file
+     */
+    outputPath: string;
+}
+/**
+ * Interface for NuGet packager service
+ */
+export interface INugetPackager {
+    /**
+     * Pack a directory into a .nupkg file
+     * @param rootPath - Root directory path to pack
+     * @param packageInfo - NuGet package metadata
+     * @param outputPath - Path where to write the .nupkg file
+     * @returns The full path to the created .nupkg file
+     */
+    packAsync(rootPath: string, packageInfo: NugetPackageInfo, outputPath: string): Promise<NugetPackagerResult>;
+}
+/**
+ * NuGet packager service - creates .nupkg files from directories
+ */
+export declare class NugetPackager implements INugetPackager {
+    private readonly fileSystem;
+    constructor(fileSystem: IFileSystem);
+    /**
+     * Pack a directory into a .nupkg file
+     * @param rootPath - Root directory path to pack
+     * @param packageInfo - NuGet package metadata
+     * @param outputPath - Path where to write the .nupkg file
+     * @returns The full path to the created .nupkg file
+     */
+    packAsync(rootPath: string, packageInfo: NugetPackageInfo, outputPath: string): Promise<NugetPackagerResult>;
+}