@qlover/fe-release 0.1.7 → 1.0.8

package/dist/index.d.ts

@@ -0,0 +1,378 @@
+import { FeScriptContextOptions, Shell, FeReleaseConfig, FeScriptContext } from '@qlover/scripts-context';
+import { AsyncExecutor, ExecutorContext, ExecutorPlugin, Logger } from '@qlover/fe-corekit';
+import { Env } from '@qlover/env-loader';
+import { OptionValues } from 'commander';
+
+interface InitOptions {
+    token?: string;
+    repoName?: string;
+    authorName?: string;
+}
+interface PullRequestInterface {
+    init(params: InitOptions): Promise<unknown>;
+    mergePullRequest(params: unknown): Promise<unknown>;
+    /**
+     *
+     * @param params
+     */
+    getPullRequest(params: {
+        pull_number: number;
+    }): Promise<unknown>;
+    deleteBranch(params: unknown): Promise<unknown>;
+    addPullRequestLabels(params: unknown): Promise<unknown>;
+    createPullRequestLabel(params: unknown): Promise<unknown>;
+    createPullRequest(params: unknown): Promise<{
+        /**
+         * pr number
+         */
+        number: number;
+        [key: string]: unknown;
+    }>;
+}
+
+interface ReleaseItProps extends ReleaseItInstanceOptions {
+    /**
+     * Receive the `release-it` instance
+     */
+    releaseIt: ReleaseItInstanceType;
+}
+type ReleaseItInstanceType = (options: ReleaseItInstanceOptions) => Promise<ReleaseItInstanceResult>;
+type ReleaseItInstanceOptions = Record<string, unknown>;
+type ReleaseItInstanceResult = {
+    changelog: string;
+    version: string;
+};
+declare class ReleaseIt {
+    private context;
+    private releaseItInstance;
+    private templateOptions;
+    private templateJson;
+    private lastPath;
+    constructor(context: ReleaseContext, props?: ReleaseItProps);
+    /**
+     * Run release-it in the publish path
+     *
+     * Because `release-it` only support signle publish path,
+     * so we need to change the current working directory to the publish path.
+     *
+     * @note This method will change the current working directory to the publish path.
+     * @param options - The options for the release-it process.
+     * @returns The output from the release-it process.
+     */
+    run(options?: ReleaseItInstanceOptions): Promise<ReleaseItInstanceResult>;
+    getOptions(context?: SharedReleaseOptions, mergeOptions?: Partial<ReleaseItInstanceOptions>): ReleaseItInstanceOptions;
+    publishNpm(): Promise<ReleaseItInstanceResult>;
+    createChangelog(): Promise<ReleaseItInstanceResult>;
+}
+
+interface PublishNpmProps {
+    npmToken?: string;
+    /**
+     * Whether to skip setting the npmrc file
+     *
+     * @default `false`
+     */
+    skipNpmrc?: boolean;
+}
+
+type ConstructorType<T, Args extends unknown[]> = (new (...args: Args) => T) | ((...args: Args) => T);
+declare function factory<T, Args extends unknown[]>(Constructor: ConstructorType<T, Args>, ...args: Args): T;
+
+declare class ReleaseTask {
+    private executor;
+    private defaultTuples;
+    protected context: ReleaseContext;
+    constructor(options?: ReleaseContextOptions, executor?: AsyncExecutor, defaultTuples?: PluginTuple<PluginClass>[]);
+    getContext(): ReleaseContext;
+    usePlugins(externalTuples?: PluginTuple<PluginClass>[]): Promise<Plugin[]>;
+    run(): Promise<unknown>;
+    exec(externalTuples?: PluginTuple<PluginClass>[]): Promise<unknown>;
+}
+
+interface WorkspacesProps {
+    /**
+     * Whether to skip workspaces
+     *
+     * @default `false`
+     */
+    skip?: boolean;
+    /**
+     * Whether to skip checking the package.json file
+     *
+     * @default `false`
+     */
+    skipCheckPackage?: boolean;
+    /**
+     * The workspace to publish
+     */
+    workspace?: WorkspaceValue;
+    /**
+     * The workspaces to publish
+     * @private
+     */
+    workspaces?: WorkspaceValue[];
+    /**
+     * The change labels
+     *
+     * from `changePackagesLabel`
+     */
+    changeLabels?: string[];
+}
+interface WorkspaceValue {
+    name: string;
+    version: string;
+    /**
+     * The relative path of the workspace
+     */
+    path: string;
+    /**
+     * The absolute path of the workspace
+     */
+    root: string;
+    /**
+     * The package.json of the workspace
+     */
+    packageJson: PackageJson;
+}
+
+type ReleaseParamsConfig = {
+    /**
+     * Max number of workspaces to include in the release name
+     *
+     * @default 3
+     */
+    maxWorkspace?: number;
+    /**
+     * Multi-workspace separator
+     *
+     * @default '_'
+     */
+    multiWorkspaceSeparator?: string;
+    /**
+     * Workspace version separator
+     *
+     * @default '@'
+     */
+    workspaceVersionSeparator?: string;
+    /**
+     * The branch name for batch release
+     *
+     * @default `batch-${releaseName}-${length}-packages`
+     */
+    batchBranchName?: string;
+    /**
+     * The PR title for batch release
+     *
+     * default from feConfig.release.PRTitle
+     *
+     * @default `Release ${env} ${pkgName} ${tagName}`
+     */
+    PRTitle?: string;
+    /**
+     * The PR body for batch release
+     *
+     * default from feConfig.release.PRBody
+     */
+    PRBody?: string;
+};
+
+interface ReleasePullRequestProps extends ReleaseParamsConfig {
+    /**
+     * The increment of the release
+     *
+     * @default `patch`
+     */
+    increment: string;
+    /**
+     * Whether to dry run the creation of the pull request
+     *
+     * @default `false`
+     */
+    dryRunCreatePR?: boolean;
+    /**
+     * The pull request interface
+     */
+    pullRequestInterface: ConstructorType<PullRequestInterface, [ReleaseContext]>;
+}
+
+interface ExecutorReleaseContext extends ExecutorContext<ReleaseContext> {
+    returnValue: ReleaseReturnValue;
+}
+type ReleaseReturnValue = {
+    githubToken?: string;
+    [key: string]: unknown;
+};
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+interface ReleaseConfig {
+    publishNpm?: PublishNpmProps;
+    githubPR?: ReleasePullRequestProps;
+    releaseIt: ReleaseItProps;
+    workspaces?: WorkspacesProps;
+}
+interface ReleaseContextOptions<T extends ReleaseConfig = ReleaseConfig> extends Omit<FeScriptContextOptions<T>, 'constructor'> {
+    shared?: SharedReleaseOptions;
+}
+type StepOption<T> = {
+    label: string;
+    task: () => Promise<T>;
+};
+type PackageJson = Record<string, unknown>;
+interface TemplateContext extends SharedReleaseOptions, WorkspaceValue {
+    publishPath: string;
+    /**
+     * @deprecated  use `releaseEnv` from `shared`
+     */
+    env: string;
+    /**
+     * @deprecated  use `sourceBranch` from `shared`
+     */
+    branch: string;
+}
+
+declare abstract class Plugin<Props = unknown> implements ExecutorPlugin<ReleaseContext> {
+    protected context: ReleaseContext;
+    readonly pluginName: string;
+    protected props: Props;
+    readonly onlyOne = true;
+    constructor(context: ReleaseContext, pluginName: string, props?: Props);
+    getInitialProps(props?: Props): Props;
+    get logger(): Logger;
+    get shell(): Shell;
+    get options(): Props;
+    getEnv(key: string, defaultValue?: string): string | undefined;
+    enabled(): boolean;
+    getConfig<T>(keys?: string | string[], defaultValue?: T): T;
+    setConfig(config: DeepPartial<Props>): void;
+    onBefore?(_context: ExecutorReleaseContext): void | Promise<void>;
+    onExec?(_context: ExecutorReleaseContext): void | Promise<void>;
+    onSuccess?(_context: ExecutorReleaseContext): void | Promise<void>;
+    onError?(_context: ExecutorReleaseContext): void | Promise<void>;
+    /**
+     * run a step
+     *
+     * this will log the step and return the result of the task
+     *
+     * @param label - the label of the step
+     * @param task - the task to run
+     * @returns the result of the task
+     */
+    step<T>({ label, task }: StepOption<T>): Promise<T>;
+}
+
+/**
+ * Represents a class that extends Plugin.
+ */
+type PluginClass<T extends unknown[] = any[]> = new (...args: T) => Plugin;
+/**
+ * Represents the constructor parameters for a specific Plugin class, excluding the first parameter.
+ * This assumes that the constructor parameters are known and can be inferred.
+ */
+type PluginConstructorParams<T extends PluginClass> = T extends new (first: any, ...args: infer P) => unknown ? P : never;
+type PluginTuple<T extends PluginClass> = [
+    T | string,
+    ...PluginConstructorParams<T>
+];
+declare function tuple<T extends PluginClass>(plugin: T | string, ...args: PluginConstructorParams<T>): PluginTuple<T>;
+
+interface SharedReleaseOptions extends FeReleaseConfig {
+    /**
+     * The source branch of the project
+     *
+     * default:
+     * - first, get from `FE_RELEASE_SOURCE_BRANCH`
+     * - second, get from `FE_RELEASE_BRANCH`
+     * - `master`
+     *
+     */
+    sourceBranch?: string;
+    /**
+     * The environment of the project
+     *
+     * default:
+     * - first, get from `FE_RELEASE_ENV`
+     * - second, get from `NODE_ENV`
+     * - `development`
+     */
+    releaseEnv?: string;
+    /**
+     * The root path of the project
+     *
+     * @default `process.cwd()`
+     */
+    rootPath?: string;
+    /**
+     * Whether to publish a PR
+     *
+     * @default `false`
+     */
+    releasePR?: boolean;
+    /**
+     * Plugins
+     */
+    plugins?: PluginTuple<PluginClass<unknown[]>>[];
+    repoName?: string;
+    authorName?: string;
+    currentBranch?: string;
+    /**
+     * Merge publish?
+     *
+     * If true, the PR will be created for all workspaces, instead of creating one PR per workspace.
+     *
+     * @default `false`
+     */
+    mergePublish?: boolean;
+}
+
+declare class ReleaseContext<T extends ReleaseConfig = ReleaseConfig> extends FeScriptContext<T> {
+    protected readonly _env: Env;
+    readonly releaseIt: ReleaseIt;
+    /**
+     * Shared Config
+     */
+    shared: SharedReleaseOptions;
+    constructor(context: ReleaseContextOptions<T>);
+    private getDefaultShreadOptions;
+    get releasePR(): boolean;
+    get rootPath(): string;
+    get sourceBranch(): string;
+    get releaseEnv(): string;
+    get env(): Env;
+    get workspaces(): WorkspaceValue[] | undefined;
+    get workspace(): WorkspaceValue | undefined;
+    setConfig(config: DeepPartial<ReleaseConfig>): void;
+    getConfig<T = unknown>(key: string | string[], defaultValue?: T): T;
+    setShared(shared: Partial<SharedReleaseOptions>): void;
+    getPkg<T>(key?: string, defaultValue?: T): T;
+    getTemplateContext(): TemplateContext;
+}
+
+type ReleaseLabelCompare = (changedFilePath: string, packagePath: string) => boolean;
+interface ReleaseLabelOptions {
+    /**
+     * The change packages label
+     */
+    changePackagesLabel: string;
+    /**
+     * The packages directories
+     */
+    packagesDirectories: string[];
+    compare?: ReleaseLabelCompare;
+}
+declare class ReleaseLabel {
+    private readonly options;
+    constructor(options: ReleaseLabelOptions);
+    compare(changedFilePath: string, packagePath: string): boolean;
+    toChangeLabel(packagePath: string, label?: string): string;
+    toChangeLabels(packages: string[], label?: string): string[];
+    pick(changedFiles: Array<string> | Set<string>, packages?: string[]): string[];
+}
+
+declare function load<T>(pluginName: string): Promise<[string, T]>;
+declare function loaderPluginsFromPluginTuples<T extends Plugin<unknown>>(context: ReleaseContext, pluginsTuples: PluginTuple<PluginClass>[], maxLimit?: number): Promise<T[]>;
+
+declare function reduceOptions(opts: OptionValues, commonKey?: string): OptionValues;
+
+export { Plugin, ReleaseContext, ReleaseLabel, ReleaseTask, factory, load, loaderPluginsFromPluginTuples, reduceOptions, tuple };
+export type { ConstructorType, DeepPartial, ExecutorReleaseContext, InitOptions, PackageJson, PluginClass, PluginConstructorParams, PluginTuple, PullRequestInterface, ReleaseConfig, ReleaseContextOptions, ReleaseLabelCompare, ReleaseLabelOptions, ReleaseReturnValue, StepOption, TemplateContext };