@salesforce/packaging 0.0.3 → 0.0.6

package/lib/package/packageVersionCreateRequest.d.ts

@@ -0,0 +1,4 @@
+import { Connection } from '@salesforce/core';
+import { Package2VersionCreateRequestResult, PackageVersionCreateRequestQueryOptions } from '../interfaces';
+export declare function list(options?: PackageVersionCreateRequestQueryOptions): Promise<Package2VersionCreateRequestResult[]>;
+export declare function byId(package2VersionCreateRequestId: any, connection: Connection): Promise<Package2VersionCreateRequestResult[]>;

package/lib/package/packageVersionCreateRequest.js

@@ -0,0 +1,85 @@
+"use strict";
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.byId = exports.list = void 0;
+const util = require("util");
+const core_1 = require("@salesforce/core");
+const packageUtils = require("../utils/packageUtils");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
+const STATUS_ERROR = 'Error';
+const QUERY = 'SELECT Id, Status, Package2Id, Package2VersionId, Package2Version.SubscriberPackageVersionId, Tag, Branch, ' +
+    'CreatedDate, Package2Version.HasMetadataRemoved, CreatedById ' +
+    'FROM Package2VersionCreateRequest ' +
+    '%s' + // WHERE, if applicable
+    'ORDER BY CreatedDate';
+const ERROR_QUERY = "SELECT Message FROM Package2VersionCreateRequestError WHERE ParentRequest.Id = '%s'";
+const STATUSES = ['Queued', 'InProgress', 'Success', 'Error'];
+async function list(options = {}) {
+    const whereClause = _constructWhere();
+    return _query(util.format(QUERY, whereClause), options.connection);
+}
+exports.list = list;
+async function byId(package2VersionCreateRequestId, connection) {
+    const results = await _query(util.format(QUERY, `WHERE Id = '${package2VersionCreateRequestId}' `), connection);
+    if (results && results.length === 1 && results[0].Status === STATUS_ERROR) {
+        results[0].Error = await _queryErrors(package2VersionCreateRequestId, connection);
+    }
+    return results;
+}
+exports.byId = byId;
+async function _query(query, connection) {
+    const queryResult = await connection.tooling.query(query);
+    return (queryResult.records ? queryResult.records : []).map((record) => ({
+        Id: record.Id,
+        Status: record.Status,
+        Package2Id: record.Package2Id,
+        Package2VersionId: record.Package2VersionId,
+        SubscriberPackageVersionId: record.Package2Version != null ? record.Package2Version.SubscriberPackageVersionId : null,
+        Tag: record.Tag,
+        Branch: record.Branch,
+        Error: [],
+        CreatedDate: packageUtils.formatDate(new Date(record.CreatedDate)),
+        HasMetadataRemoved: record.Package2Version != null ? record.Package2Version.HasMetadataRemoved : null,
+        CreatedBy: record.CreatedById,
+    }));
+}
+async function _queryErrors(package2VersionCreateRequestId, connection) {
+    const errorResults = [];
+    const queryResult = connection.tooling.query(util.format(ERROR_QUERY, package2VersionCreateRequestId));
+    if (queryResult.records) {
+        queryResult.records.forEach((record) => {
+            errorResults.push(record.Message);
+        });
+    }
+    return errorResults;
+}
+function _constructWhere(options) {
+    const where = [];
+    // filter on created date, days ago: 0 for today, etc
+    if (!util.isNullOrUndefined(this.options.createdlastdays)) {
+        if (options.createdlastdays < 0) {
+            throw new Error(messages.getMessage('invalidDaysNumber', ['createdlastdays', options.createdlastdays]));
+        }
+        where.push(`CreatedDate = LAST_N_DAYS:${this.options.createdlastdays}`);
+    }
+    // filter on errors
+    if (options.status) {
+        const foundStatus = STATUSES.find((status) => status.toLowerCase() === this.options.status.toLowerCase());
+        if (!foundStatus) {
+            const args = [options.status];
+            STATUSES.forEach((status) => {
+                args.push(status);
+            });
+            throw new Error(messages.getMessage('invalidStatus', args));
+        }
+        where.push(`Status = '${foundStatus}'`);
+    }
+    return where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
+}
+//# sourceMappingURL=packageVersionCreateRequest.js.map

package/lib/package/packageVersionList.d.ts

@@ -0,0 +1,9 @@
+import { SfProject } from '@salesforce/core';
+import { QueryResult } from 'jsforce';
+import { PackageVersionListResult, PackageVersionQueryOptions } from '../interfaces';
+export declare const DEFAULT_ORDER_BY_FIELDS = "Package2Id, Branch, MajorVersion, MinorVersion, PatchVersion, BuildNumber";
+export declare function listPackageVersions(options: PackageVersionQueryOptions): Promise<QueryResult<PackageVersionListResult>>;
+export declare function _constructQuery(options: PackageVersionQueryOptions): string;
+export declare function _assembleQueryParts(select: string, where: string[], orderBy?: string): string;
+export declare function _constructWhere(idsOrAliases: string[], createdLastDays: number, lastModLastDays: number, project: SfProject): string[];
+export declare function _getLastDays(paramName: string, lastDays: number): number;

package/lib/package/packageVersionList.js

@@ -0,0 +1,91 @@
+"use strict";
+/*
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getLastDays = exports._constructWhere = exports._assembleQueryParts = exports._constructQuery = exports.listPackageVersions = exports.DEFAULT_ORDER_BY_FIELDS = void 0;
+const core_1 = require("@salesforce/core");
+const ts_types_1 = require("@salesforce/ts-types");
+const utils_1 = require("../utils");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
+// Stripping CodeCoverage, HasPassedCodeCoverageCheck as they are causing a perf issue in 47.0+ W-6997762
+const DEFAULT_SELECT = 'SELECT Id, Package2Id, SubscriberPackageVersionId, Name, Package2.Name, Package2.NamespacePrefix, ' +
+    'Description, Tag, Branch, MajorVersion, MinorVersion, PatchVersion, BuildNumber, IsReleased, ' +
+    'CreatedDate, LastModifiedDate, IsPasswordProtected, AncestorId, ValidationSkipped, CreatedById ' +
+    'FROM Package2Version';
+const VERBOSE_SELECT = 'SELECT Id, Package2Id, SubscriberPackageVersionId, Name, Package2.Name, Package2.NamespacePrefix, ' +
+    'Description, Tag, Branch, MajorVersion, MinorVersion, PatchVersion, BuildNumber, IsReleased, ' +
+    'CreatedDate, LastModifiedDate, IsPasswordProtected, CodeCoverage, HasPassedCodeCoverageCheck, AncestorId, ValidationSkipped, ' +
+    'ConvertedFromVersionId, Package2.IsOrgDependent, ReleaseVersion, BuildDurationInSeconds, HasMetadataRemoved, CreatedById ' +
+    'FROM Package2Version';
+exports.DEFAULT_ORDER_BY_FIELDS = 'Package2Id, Branch, MajorVersion, MinorVersion, PatchVersion, BuildNumber';
+const logger = core_1.Logger.childFromRoot('packageVersionList');
+async function listPackageVersions(options) {
+    return options.connection.tooling.query(_constructQuery(options));
+}
+exports.listPackageVersions = listPackageVersions;
+function _constructQuery(options) {
+    // construct custom WHERE clause, if applicable
+    const where = _constructWhere(options.packages, options.createdLastDays, options.modifiedLastDays, options.project);
+    if (options.isReleased) {
+        where.push('IsReleased = true');
+    }
+    return _assembleQueryParts(options.verbose === true ? VERBOSE_SELECT : DEFAULT_SELECT, where, options.orderBy);
+}
+exports._constructQuery = _constructQuery;
+function _assembleQueryParts(select, where, orderBy = exports.DEFAULT_ORDER_BY_FIELDS) {
+    // construct ORDER BY clause
+    // TODO: validate given fields
+    const orderByPart = `ORDER BY ${orderBy ? orderBy : exports.DEFAULT_ORDER_BY_FIELDS}`;
+    const wherePart = where.length > 0 ? `WHERE ${where.join(' AND ')}` : '';
+    const query = `${select} ${wherePart} ${orderByPart}`;
+    logger.debug(query);
+    return query;
+}
+exports._assembleQueryParts = _assembleQueryParts;
+// construct custom WHERE clause parts
+function _constructWhere(idsOrAliases, createdLastDays, lastModLastDays, project) {
+    const where = [];
+    // filter on given package ids
+    if ((idsOrAliases === null || idsOrAliases === void 0 ? void 0 : idsOrAliases.length) > 0) {
+        // remove dups
+        const aliasesOrIds = [...new Set(idsOrAliases)];
+        // resolve any aliases
+        const packageIds = aliasesOrIds.map((idOrAlias) => (0, utils_1.getPackageIdFromAlias)(idOrAlias, project));
+        // validate ids
+        packageIds.forEach((packageId) => {
+            (0, utils_1.validateId)(utils_1.BY_LABEL.PACKAGE_ID, packageId);
+        });
+        // stash where part
+        where.push(`Package2Id IN ('${packageIds.join("','")}')`);
+    }
+    // filter on created date, days ago: 0 for today, etc
+    if ((0, ts_types_1.isNumber)(createdLastDays)) {
+        createdLastDays = _getLastDays('createdlastdays', createdLastDays);
+        where.push(`CreatedDate = LAST_N_DAYS:${createdLastDays}`);
+    }
+    // filter on last mod date, days ago: 0 for today, etc
+    if ((0, ts_types_1.isNumber)(lastModLastDays)) {
+        lastModLastDays = _getLastDays('modifiedlastdays', lastModLastDays);
+        where.push(`LastModifiedDate = LAST_N_DAYS:${lastModLastDays}`);
+    }
+    // exclude deleted
+    where.push('IsDeprecated = false');
+    return where;
+}
+exports._constructWhere = _constructWhere;
+function _getLastDays(paramName, lastDays) {
+    if (isNaN(lastDays)) {
+        return 0;
+    }
+    if (lastDays < 0) {
+        throw messages.createError('invalidDaysNumber', [paramName, `${lastDays}`]);
+    }
+    return lastDays;
+}
+exports._getLastDays = _getLastDays;
+//# sourceMappingURL=packageVersionList.js.map

package/lib/package/profileApi.d.ts

@@ -0,0 +1,55 @@
+import { ConfigAggregator, SfProject } from '@salesforce/core';
+export declare class ProfileApi {
+    project: SfProject;
+    includeUserLicenses: boolean;
+    generateProfileInformation: boolean;
+    readonly profiles: ProfileInformation[];
+    apiVersion: string;
+    nodeEntities: {
+        name: string[];
+        childElement: string[];
+        parentElement: string[];
+    };
+    otherProfileSettings: {
+        name: string[];
+        childElement: string[];
+        parentElement: string[];
+    };
+    config: ConfigAggregator;
+    constructor(project: SfProject, includeUserLicenses: boolean, generateProfileInformation?: boolean);
+    /**
+     * For any profile present in the workspace, this function generates a subset of data that only contains references
+     * to items in the manifest.
+     *
+     * @param destPath location of new profiles
+     * @param manifest
+     * @param excludedDirectories Directories to not include profiles from
+     */
+    generateProfiles(destPath: string, manifest: {
+        Package: {
+            types: string[];
+        };
+    }, excludedDirectories?: string[]): any[];
+    /**
+     * Filter out all profiles in the manifest and if any profiles exists in the workspace, add them to the manifest.
+     *
+     * @param typesArr array of objects { name[], members[] } that represent package types JSON.
+     * @param excludedDirectories Direcotires not to generate profiles for
+     */
+    filterAndGenerateProfilesForManifest(typesArr: any, excludedDirectories?: string[]): any;
+    getProfileInformation(): ProfileInformation[];
+    private copyNodes;
+    private findAllProfiles;
+}
+declare class ProfileInformation {
+    ProfileName: string;
+    ProfilePath: string;
+    IsPackaged: boolean;
+    settingsRemoved: string[];
+    constructor(ProfileName: string, ProfilePath: string, IsPackaged: boolean, settingsRemoved: string[]);
+    setIsPackaged(IsPackaged: boolean): void;
+    appendRemovedSetting(setting: string): void;
+    logDebug(): string;
+    logInfo(): string;
+}
+export {};

package/lib/package/profileApi.js

@@ -0,0 +1,275 @@
+"use strict";
+/*
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileApi = void 0;
+const path = require("path");
+const fs = require("fs");
+const glob = require("glob");
+const xmldom_sfdx_encoding_1 = require("xmldom-sfdx-encoding");
+const core_1 = require("@salesforce/core");
+// Local
+core_1.Messages.importMessagesDirectory(__dirname);
+// TODO: need to transfer these messages
+const profileApiMessages = core_1.Messages.loadMessages('@salesforce/packaging', 'messages');
+/*
+ * This class provides functions used to re-write .profiles in the workspace when creating a package2 version.
+ * All profiles found in the workspaces are extracted out and then re-written to only include metadata in the profile
+ * that is relevant to the source in the package directory being packaged.
+ */
+class ProfileApi {
+    constructor(project, includeUserLicenses, generateProfileInformation = false) {
+        this.project = project;
+        this.includeUserLicenses = includeUserLicenses;
+        this.generateProfileInformation = generateProfileInformation;
+        this.profiles = [];
+        (async () => {
+            this.config = await core_1.ConfigAggregator.create();
+        })();
+        this.apiVersion = this.config.getPropertyValue('apiVersion');
+        // nodeEntities is used to determine which elements in the profile are relevant to the source being packaged.
+        // name refers to the entity type name in source that the element pertains to.  As an example, a profile may
+        // have an entry like the example below, which should only be added to the packaged profile if the related
+        // CustomObject is in the source being packaged:
+        //   <objectPermissions>
+        //      <allowCreate>true</allowCreate>
+        //       ...
+        //      <object>MyCustomObject__c</object>
+        //       ...
+        //   </objectPermissions>
+        //
+        // For this example: nodeEntities.parentElement = objectPermissions and nodeEntities.childElement = object
+        this.nodeEntities = {
+            name: [
+                'CustomObject',
+                'CustomField',
+                'Layout',
+                'CustomTab',
+                'CustomApplication',
+                'ApexClass',
+                'CustomPermission',
+                'ApexPage',
+                'ExternalDataSource',
+                'RecordType',
+            ],
+            parentElement: [
+                'objectPermissions',
+                'fieldPermissions',
+                'layoutAssignments',
+                'tabVisibilities',
+                'applicationVisibilities',
+                'classAccesses',
+                'customPermissions',
+                'pageAccesses',
+                'externalDataSourceAccesses',
+                'recordTypeVisibilities',
+            ],
+            childElement: [
+                'object',
+                'field',
+                'layout',
+                'tab',
+                'application',
+                'apexClass',
+                'name',
+                'apexPage',
+                'externalDataSource',
+                'recordType',
+            ],
+        };
+        // There are some profile settings that are allowed to be packaged that may not necessarily map to a specific metadata
+        // object. We should still handle these accordingly, but a little differently than the above mentioned types.
+        this.otherProfileSettings = {
+            name: ['CustomSettings', 'CustomMetadataTypeAccess'],
+            parentElement: ['customSettingAccesses', 'customMetadataTypeAccesses'],
+            childElement: ['name', 'name'],
+        };
+    }
+    /**
+     * For any profile present in the workspace, this function generates a subset of data that only contains references
+     * to items in the manifest.
+     *
+     * @param destPath location of new profiles
+     * @param manifest
+     * @param excludedDirectories Directories to not include profiles from
+     */
+    generateProfiles(destPath, manifest, excludedDirectories = []) {
+        const excludedProfiles = [];
+        const profilePaths = this.findAllProfiles(excludedDirectories);
+        if (!profilePaths) {
+            return excludedProfiles;
+        }
+        profilePaths.forEach((profilePath) => {
+            // profile metadata can present in any directory in the package structure
+            const profileName = profilePath.match(/([^/]+)\.profile-meta.xml/)[1];
+            const profileDom = new xmldom_sfdx_encoding_1.DOMParser().parseFromString(fs.readFileSync(profilePath, 'utf-8'));
+            const newDom = new xmldom_sfdx_encoding_1.DOMParser().parseFromString('<?xml version="1.0" encoding="UTF-8"?><Profile xmlns="http://soap.sforce.com/2006/04/metadata"></Profile>');
+            const profileNode = newDom.getElementsByTagName('Profile')[0];
+            let hasNodes = false;
+            // We need to keep track of all the members for when we package up the "OtherProfileSettings"
+            let allMembers = [];
+            manifest.Package.types.forEach((element) => {
+                const name = element['name'];
+                const members = element['members'];
+                allMembers = allMembers.concat(members);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                const idx = this.nodeEntities.name.indexOf(name[0]);
+                if (idx > -1) {
+                    hasNodes =
+                        this.copyNodes(profileDom, this.nodeEntities.parentElement[idx], this.nodeEntities.childElement[idx], members, profileNode, profileName) || hasNodes;
+                }
+            });
+            // Go through each of the other profile settings we might want to include. We pass in "all" the members since these
+            // will reference anything that could be packaged. The "copyNodes" function will only include the type if it
+            // exists in the profile itself
+            this.otherProfileSettings.name.forEach((element) => {
+                const idx = this.otherProfileSettings.name.indexOf(element);
+                if (idx > -1) {
+                    hasNodes =
+                        this.copyNodes(profileDom, this.otherProfileSettings.parentElement[idx], this.otherProfileSettings.childElement[idx], allMembers, profileNode, profileName) || hasNodes;
+                }
+            });
+            // add userLicenses to the profile
+            if (this.includeUserLicenses === true) {
+                const userLicenses = profileDom.getElementsByTagName('userLicense');
+                if (userLicenses) {
+                    hasNodes = true;
+                    for (const userLicense of userLicenses) {
+                        profileNode.appendChild(userLicense.cloneNode(true));
+                    }
+                }
+            }
+            const xmlSrcFile = path.basename(profilePath);
+            const xmlFile = xmlSrcFile.replace(/(.*)(-meta.xml)/, '$1');
+            const destFilePath = path.join(destPath, xmlFile);
+            if (hasNodes) {
+                const serializer = new xmldom_sfdx_encoding_1.XMLSerializer();
+                serializer.serializeToString(newDom);
+                fs.writeFileSync(destFilePath, serializer.serializeToString(newDom), 'utf-8');
+            }
+            else {
+                // remove from manifest
+                // eslint-disable-next-line @typescript-eslint/no-shadow
+                const profileName = xmlFile.replace(/(.*)(\.profile)/, '$1');
+                excludedProfiles.push(profileName);
+                if (this.generateProfileInformation) {
+                    const profile = this.profiles.find(({ ProfileName }) => ProfileName === profileName);
+                    if (profile) {
+                        profile.setIsPackaged(false);
+                    }
+                }
+                try {
+                    fs.unlinkSync(destFilePath);
+                }
+                catch (err) {
+                    // It is normal for the file to not exist if the profile is in the worskpace but not in the directory being packaged.
+                    if (err.code !== 'ENOENT') {
+                        throw err;
+                    }
+                }
+            }
+        });
+        return excludedProfiles;
+    }
+    /**
+     * Filter out all profiles in the manifest and if any profiles exists in the workspace, add them to the manifest.
+     *
+     * @param typesArr array of objects { name[], members[] } that represent package types JSON.
+     * @param excludedDirectories Direcotires not to generate profiles for
+     */
+    filterAndGenerateProfilesForManifest(typesArr, excludedDirectories = []) {
+        const profilePaths = this.findAllProfiles(excludedDirectories);
+        // Filter all profiles
+        typesArr = typesArr.filter((kvp) => kvp.name[0] !== 'Profile');
+        if (profilePaths) {
+            const members = [];
+            profilePaths.forEach((profilePath) => {
+                // profile metadata can present in any directory in the package structure
+                const profileName = profilePath.match(/([^/]+)\.profile-meta.xml/)[1];
+                members.push(profileName);
+                if (this.generateProfileInformation) {
+                    this.profiles.push(new ProfileInformation(profileName, profilePath, true, []));
+                }
+            });
+            if (members.length > 0) {
+                typesArr.push({ name: ['Profile'], members });
+            }
+        }
+        return typesArr;
+    }
+    getProfileInformation() {
+        return this.profiles;
+    }
+    copyNodes(originalDom, parentElement, childElement, members, appendToNode, profileName) {
+        let nodesAdded = false;
+        const nodes = originalDom.getElementsByTagName(parentElement);
+        if (!nodes) {
+            return nodesAdded;
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let i = 0; i < nodes.length; i++) {
+            const name = nodes[i].getElementsByTagName(childElement)[0].childNodes[0].nodeValue;
+            if (members.indexOf(name) >= 0) {
+                // appendChild will take the passed in node (newNode) and find the parent if it exists and then remove
+                // the newNode from the parent.  This causes issues with the way this is copying the nodes, so pass in a clone instead.
+                const currentNode = nodes[i].cloneNode(true);
+                appendToNode.appendChild(currentNode);
+                nodesAdded = true;
+            }
+            else {
+                // Tell the user which profile setting has been removed from the package
+                if (this.generateProfileInformation) {
+                    const profile = this.profiles.find(({ ProfileName }) => ProfileName === profileName);
+                    if (profile) {
+                        profile.appendRemovedSetting(name);
+                    }
+                }
+            }
+        }
+        return nodesAdded;
+    }
+    findAllProfiles(excludedDirectories = []) {
+        return glob.sync(path.join(this.project.getPath(), '**', '*.profile-meta.xml'), {
+            ignore: excludedDirectories.map((dir) => `**/${dir}/**`),
+        });
+    }
+}
+exports.ProfileApi = ProfileApi;
+class ProfileInformation {
+    constructor(ProfileName, ProfilePath, IsPackaged, settingsRemoved) {
+        this.ProfileName = ProfileName;
+        this.ProfilePath = ProfilePath;
+        this.IsPackaged = IsPackaged;
+        this.settingsRemoved = settingsRemoved;
+    }
+    setIsPackaged(IsPackaged) {
+        this.IsPackaged = IsPackaged;
+    }
+    appendRemovedSetting(setting) {
+        this.settingsRemoved.push(setting);
+    }
+    logDebug() {
+        let info = profileApiMessages.getMessage('profile_api.addProfileToPackage', [this.ProfileName, this.ProfilePath]);
+        this.settingsRemoved.forEach((setting) => {
+            info += '\n\t' + profileApiMessages.getMessage('profile_api.removeProfileSetting', [setting, this.ProfileName]);
+        });
+        if (!this.IsPackaged) {
+            info += '\n\t' + profileApiMessages.getMessage('profile_api.removeProfile', [this.ProfileName]);
+        }
+        info += '\n';
+        return info;
+    }
+    logInfo() {
+        if (this.IsPackaged) {
+            return profileApiMessages.getMessage('profile_api.addProfileToPackage', [this.ProfileName, this.ProfilePath]);
+        }
+        else {
+            return profileApiMessages.getMessage('profile_api.profileNotIncluded', [this.ProfileName]);
+        }
+    }
+}
+//# sourceMappingURL=profileApi.js.map

package/lib/utils/index.d.ts

@@ -1 +1,2 @@
 export * from './packageUtils';
+export * from './srcDevUtils';

package/lib/utils/index.js

@@ -21,4 +21,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 __exportStar(require("./packageUtils"), exports);
+__exportStar(require("./srcDevUtils"), exports);
 //# sourceMappingURL=index.js.map

package/lib/utils/packageUtils.d.ts

@@ -1,8 +1,8 @@
-import { Connection, NamedPackageDir, PackageDir, SfProject } from '@salesforce/core';
+import { Connection, NamedPackageDir, PackageDir, SfError, SfProject } from '@salesforce/core';
 import { Duration } from '@salesforce/kit';
 import { Many } from '@salesforce/ts-types';
-import { PackagingSObjects, Package2VersionCreateRequestResult } from '../interfaces';
-import { PackageVersionCreateRequestApi } from '../package/packageVersionCreateRequestApi';
+import { SaveError } from 'jsforce';
+import { PackagingSObjects, Package2VersionCreateRequestResult, PackageVersionCreateOptions } from '../interfaces';
 export declare const VERSION_NUMBER_SEP = ".";
 export declare type IdRegistryValue = {
     prefix: string;
@@ -123,7 +123,7 @@ export declare function getAncestorIdHighestRelease(connection: Connection, pack
 export declare function concatVersion(major: string | number, minor: string | number, patch: string | number, build: string | number): string;
 export declare function getPackage2VersionNumber(package2VersionObj: PackagingSObjects.Package2Version): string;
 export declare function getConfigPackageDirectories(project: SfProject): PackageDir[];
-export declare function getConfigPackageDirectory(packageDirs: NamedPackageDir[], lookupProperty: string, lookupValue: unknown): NamedPackageDir | undefined;
+export declare function getConfigPackageDirectory(packageDirs: NamedPackageDir[] | PackageDir[], lookupProperty: string, lookupValue: unknown): NamedPackageDir | PackageDir | undefined;
 /**
  * Given a packageAlias, attempt to return the associated id from the config
  *
@@ -146,7 +146,8 @@ export declare function convertCamelCaseStringToSentence(stringIn: string): stri
  */
 export declare function getPackageAliasesFromId(packageId: string, project: SfProject): string[];
 export declare function findOrCreatePackage2(seedPackage: string, connection: Connection): Promise<string>;
-export declare function _getPackageVersionCreateRequestApi(connection: Connection): PackageVersionCreateRequestApi;
-export declare function pollForStatusWithInterval(context: any, id: string, retries: number, packageId: string, branch: string, withProject: SfProject, connection: Connection, interval: Duration): Promise<Package2VersionCreateRequestResult>;
+export declare function pollForStatusWithInterval(id: string, retries: number, packageId: string, branch: string, withProject: SfProject, connection: Connection, interval: Duration): Promise<Package2VersionCreateRequestResult>;
 export declare function getSoqlWhereClauseMaxLength(): number;
 export declare function formatDate(date: Date): string;
+export declare function combineSaveErrors(sObject: string, crudOperation: string, errors: SaveError[]): SfError;
+export declare function resolveCanonicalPackageProperty(options: PackageVersionCreateOptions): "id" | "package";