@fastkit/plugboy 0.0.1

package/dist/plugboy.d.ts

@@ -0,0 +1,619 @@
+import { Options } from 'tsup';
+import fs from 'node:fs';
+import { PackageJson } from 'pkg-types';
+import { CompilerOptions } from 'typescript';
+import { Plugin as Plugin$1 } from 'esbuild';
+
+type ESBuildPluginType = NonNullable<Options['esbuildPlugins']>[number];
+interface ESBuildPlugin extends ESBuildPluginType {
+}
+
+declare function isPromise<T = any>(obj: any): obj is Promise<T>;
+type Listable<T> = T | false | null | undefined | Listable<T>[] | Promise<T | false | null | undefined | Listable<T>[]>;
+declare function resolveListable<T>(raw: Listable<T>): Promise<T[]>;
+
+declare function getFilename(importMetaURL: string): string;
+declare function getDirname(importMetaURL: string): string;
+declare function isFileNotFoundException(source: unknown): source is NodeJS.ErrnoException;
+declare function pathExists(target: string, type?: 'file' | 'dir'): Promise<boolean>;
+type FileMatcherFn = (file: fs.Dirent, dir: string) => boolean | Promise<boolean>;
+type FileMatcher = string | RegExp | FileMatcherFn;
+declare function findFile(dir: string, matcher: FileMatcher, recursive?: boolean): Promise<string | undefined>;
+interface FindConfigResult {
+    dir: string;
+    fileName: string;
+    path: string;
+    code: string;
+}
+interface FindConfigSettings<AllowMissing extends boolean | undefined> {
+    fileName: string | string[];
+    allowMissing?: AllowMissing;
+    test?: (result: FindConfigResult) => boolean;
+    /**
+     * Trace up to how many directories above
+     * @default 10
+     */
+    depth?: number;
+}
+declare function findConfig<AllowMissing extends boolean | undefined = false>(fileNameOrSettings: string | string[] | FindConfigSettings<AllowMissing>, dir?: string, currentDepth?: number): Promise<AllowMissing extends true ? FindConfigResult | null : FindConfigResult>;
+declare function rmrf(...paths: string[]): Promise<void>;
+declare function copyDirSync(srcDir: string, destDir: string): void;
+
+declare function isWorkspacePackageJson(json: PackageJson): json is WorkspacePackageJson;
+declare function resolveRawWorkspaceEntry(entry: RawWorkspaceEntry): WorkspaceEntry;
+declare function resolveRawWorkspaceEntries(entries: RawWorkspaceEntries | undefined): WorkspaceEntries;
+declare function resolveUserWorkspaceConfig(userConfig: UserWorkspaceConfig): Promise<ResolvedWorkspaceConfig>;
+declare function defineWorkspaceConfig<Config extends UserWorkspaceConfig>(config: Config): Promise<ResolvedWorkspaceConfig>;
+declare function loadWorkspaceConfig(searchDir?: string, depth?: number): Promise<ResolvedWorkspaceConfig>;
+
+declare function resolveUserHooks(...userHooks: (UserHooks | undefined | null | false)[]): Promise<ResolvedHooks>;
+declare function buildHooks(resolvedHooks: ResolvedHooks): BuildedHooks;
+
+declare function resolveUserPluginOptions(pluginOptions: UserPluginOption[] | undefined): Promise<Plugin[]>;
+declare function definePlugin<T extends Plugin>(options: T): T;
+declare function extractProjectPlugins(searchDir?: string): Promise<Plugin[]>;
+declare function findProjectPlugin<T extends Plugin = Plugin>(pluginName: string, searchDir?: string): Promise<T | undefined>;
+
+declare function isProjectPackageJson(json: PackageJson): json is ProjectPackageJson;
+declare function resolveUserProjectConfig(userConfig: UserProjectConfig): Promise<ResolvedProjectConfig>;
+declare function defineProjectConfig<Config extends UserProjectConfig>(config: Config): Promise<ResolvedProjectConfig>;
+declare function loadProjectConfig(searchDir?: string, depth?: number): Promise<ResolvedProjectConfig>;
+
+declare class Path {
+    private _value;
+    private _stats?;
+    get value(): string;
+    set value(value: string);
+    get dirname(): string;
+    get basename(): string;
+    get extname(): string;
+    get stats(): fs.Stats;
+    get isDirectory(): () => boolean;
+    get isFile(): () => boolean;
+    constructor(value: string);
+    toString(): string;
+    valueOf(): string;
+    toJSON(): string;
+    relative(to: string): Path;
+    join(...paths: string[]): Path;
+    resolve(...paths: string[]): Path;
+    private _join;
+    readdir(...paths: string[]): Promise<Path[]>;
+    readFile<D = undefined>(pathAppend?: string, defaults?: D): Promise<D extends undefined ? string : string | D>;
+    readJSON<T = any, D = undefined>(pathAppend?: string, defaults?: D): Promise<D extends undefined ? T : T | D>;
+}
+
+type RequiredPackageJSON<Field extends string> = PackageJson & Required<Pick<PackageJson, Field>>;
+
+/**
+ * Plugboy Project
+ *
+ * @remarks This instance is only created if the project consists of a mono-repo.
+ */
+declare class PlugboyProject {
+    /** Path instance of the project directory */
+    readonly dir: Path;
+    /** package.json */
+    readonly json: ProjectPackageJson;
+    /**
+     * Project Configuration
+     * @see {@link ResolvedProjectConfig}
+     */
+    readonly config: ResolvedProjectConfig;
+    /** Names of all packages on which the project depends */
+    readonly dependencies: string[];
+    /** Directory names of all workspaces owned by the project */
+    readonly resolvedWorkspaces: string[];
+    /**
+     * Name of the project's package.json
+     */
+    get name(): string;
+    /**
+     * Plug-in List
+     * @see {@link ResolvedProjectConfig.plugins}
+     */
+    get plugins(): Plugin[];
+    /**
+     * List of all user hook settings
+     * @see {@link UserHooks}
+     */
+    get hooks(): UserHooks[];
+    constructor(ctx: ProjectSetupContext);
+}
+declare function getProject<AllowMissing extends boolean | undefined = false>(searchDir?: string, allowMissing?: AllowMissing, skipLoadConfig?: boolean): Promise<AllowMissing extends true ? PlugboyProject | null : PlugboyProject>;
+
+type WorkspaceStubLink = {
+    type: 'js';
+    from: string;
+    to: string;
+} | {
+    type: 'css';
+    from: string;
+};
+type WorkspaceStubLinkType = WorkspaceStubLink['type'];
+interface WorkspaceObjectExport {
+    src: string;
+    types: string;
+    dtsDest: string;
+    import: {
+        default: string;
+    };
+}
+interface WorkspaceExport {
+    id: string;
+    at: string | WorkspaceObjectExport;
+    stubLink?: WorkspaceStubLink;
+}
+declare const WORKSPACE_PACKAGE_SYNC_FIELDS: readonly ["repository", "author", "publishConfig", "license"];
+declare function syncWorkspacePackageFields(projectJSON: ProjectPackageJson, workspaceJSON: WorkspacePackageJson): void;
+declare class PlugboyWorkspace {
+    readonly name: string;
+    readonly dir: Path;
+    readonly config: ResolvedWorkspaceConfig;
+    readonly project: PlugboyProject | null;
+    readonly dirs: WorkspaceDirs;
+    readonly dependencies: string[];
+    readonly projectDependencies: string[];
+    readonly meta: WorkspaceMeta;
+    readonly entry: Record<string, string>;
+    readonly exports: WorkspaceExport[];
+    readonly builder: Builder;
+    readonly plugins: Plugin[];
+    readonly hooks: BuildedHooks;
+    readonly dtsFiles: string[];
+    readonly dts: NormalizedDTSSettings;
+    private _json;
+    get json(): WorkspacePackageJson;
+    constructor(ctx: WorkspaceSetupContext);
+    clean(withDepsAndCache?: boolean): Promise<void>;
+    preparePackageJSON(): Promise<WorkspacePackageJson>;
+    getStubLinks(): WorkspaceStubLink[];
+    stub(): Promise<void>;
+    getESBuildPlugins(): Promise<ESBuildPlugin[]>;
+    build(): Promise<void>;
+}
+declare function getWorkspace<AllowMissing extends boolean | undefined = false>(searchDir?: string, allowMissing?: AllowMissing): Promise<AllowMissing extends true ? PlugboyWorkspace | null : PlugboyWorkspace>;
+
+interface ResolvedOptions extends Options {
+    esbuildPlugins: Plugin$1[];
+}
+declare class Builder {
+    readonly workspace: PlugboyWorkspace;
+    private _tsupOptions?;
+    get entry(): Record<string, string>;
+    get dts(): NormalizedDTSSettings;
+    constructor(workspace: PlugboyWorkspace);
+    tsupOptions(overrides?: {
+        watch?: boolean;
+    }): Promise<ResolvedOptions>;
+    private _stubLinkJS;
+    private _stubLinkCSS;
+    copyPublicDir(): Promise<void>;
+    stub(): Promise<void>;
+    normalizeDTSBySettings(dts: string, settings: NormalizedDTSPreserveTypeSettings): string | undefined;
+    normalizeDTSFile(filePath: string): Promise<void>;
+    normalizeDTSFiles(dtsFiles?: string[]): Promise<void>;
+    emitInlineDTS(): Promise<void>;
+    build(): Promise<void>;
+}
+
+declare function generateWorkspace(workspaceName?: string, cwd?: string): Promise<void>;
+
+type ESBuildPluginOption = ESBuildPlugin | undefined | false | null | Promise<ESBuildPlugin | undefined | false | null> | ((workspace: PlugboyWorkspace) => ESBuildPlugin | undefined | false | null | Promise<ESBuildPlugin | undefined | false | null>);
+interface Plugin {
+    name: string;
+    hooks?: UserHooks;
+    esbuildPlugins?: ESBuildPluginOption[];
+}
+type UserPluginOption = Listable<Plugin>;
+
+/**
+ * Type preservation target in d.ts file
+ */
+interface DTSPreserveTypeTarget {
+    /** Type name */
+    typeName: string;
+    /**
+     * String to be restored or regular expression to match
+     */
+    from: string | RegExp;
+}
+/**
+ * Type preservation target in d.ts file (normalized)
+ *
+ * @see {@link DTSPreserveTypeTarget}
+ */
+interface NormalizedDTSPreserveTypeTarget extends Omit<DTSPreserveTypeTarget, 'from'> {
+    /** Regular expression to match the string to be restored */
+    from: RegExp;
+}
+declare function normalizeDTSPreserveTypeTarget(target: DTSPreserveTypeTarget): NormalizedDTSPreserveTypeTarget;
+/**
+ * Type preservation setting for d.ts files
+ *
+ * @remarks This setting is for restoring type information inlined by the TypeScript compiler to the original type name by string substitution.
+ */
+interface DTSPreserveTypeSettings {
+    /** Name of the package to which the type to be restored belongs */
+    pkg?: string;
+    /** List of preservation targets */
+    targets: DTSPreserveTypeTarget[];
+}
+/**
+ * Type preservation setting for d.ts files (normalized)
+ *
+ * @see {@link DTSPreserveTypeSettings}
+ */
+interface NormalizedDTSPreserveTypeSettings extends Omit<DTSPreserveTypeSettings, 'targets'> {
+    /** List of normalized type preservation targets */
+    targets: NormalizedDTSPreserveTypeTarget[];
+}
+declare function normalizeDTSPreserveTypeSettings(settings: DTSPreserveTypeSettings): NormalizedDTSPreserveTypeSettings;
+/**
+ * d.ts output setting
+ */
+interface DTSSettings {
+    /**
+     * Inline output without bundling d.ts
+     *
+     * @default false
+     */
+    inline?: boolean;
+    /**
+     * list of type preservation settings
+     *
+     * @remarks This setting is for restoring type information inlined by the TypeScript compiler to the original type name by string substitution.
+     *
+     * @see {@link DTSPreserveTypeSettings}
+     */
+    preserveType?: DTSPreserveTypeSettings[];
+}
+/**
+ * d.ts output setting (normalized)
+ *
+ * @see {@link DTSSettings}
+ */
+interface NormalizedDTSSettings {
+    /**
+     * Inline output without bundling d.ts
+     */
+    inline: boolean;
+    /**
+     * list of type preservation settings
+     */
+    preserveType: NormalizedDTSPreserveTypeSettings[];
+}
+declare function normalizeDTSSettings(settings: DTSSettings): NormalizedDTSSettings;
+declare function mergeDTSSettingsList(...settingsList: (DTSSettings | undefined)[]): NormalizedDTSSettings;
+
+declare const WORKSPACE_REQUIRED_FIELDS: readonly ["name", "version"];
+type WorkspaceRequiredField = (typeof WORKSPACE_REQUIRED_FIELDS)[number];
+/**
+ * Entry setting object
+ */
+interface RawWorkspaceEntryObject {
+    /**
+     * Entry file path
+     *
+     * @remarks It must be relative to the root directory of the workspace.
+     */
+    src: string;
+    /**
+     * Set to true if the entry outputs css at the same time
+     *
+     * @remarks By doing this, the exports field in package.json will be set automatically.
+     */
+    css?: boolean;
+}
+/**
+ * Entry setting object
+ */
+type WorkspaceEntry = Required<RawWorkspaceEntryObject>;
+type RawWorkspaceEntry = string | RawWorkspaceEntryObject;
+/**
+ * Configuration of all entries in the workspace (normalized)
+ *
+ * @see {@link RawWorkspaceEntries}
+ */
+type WorkspaceEntries = Record<string, WorkspaceEntry>;
+/**
+ * Configuration of all entries in the workspace
+ *
+ * @remarks The configuration must be `{ [id]: [Entry setting: }`. `"." ` is treated as a special ID and is the target of the main export.
+ */
+type RawWorkspaceEntries = Record<string, RawWorkspaceEntry>;
+declare const TSUP_SYNC_OPTIONS: readonly ["define", "noExternal", "external", "replaceNodeEnv", "skipNodeModulesBundle"];
+type TSUpSyncOption = (typeof TSUP_SYNC_OPTIONS)[number];
+interface TSUpSyncOptions extends Pick<Options, TSUpSyncOption> {
+}
+/**
+ * Workspace User Configuration
+ */
+interface UserWorkspaceConfig extends TSUpSyncOptions {
+    /**
+     * Ignore project settings
+     *
+     * @remarks Normally, when processing a workspace, plugboy looks for and merges the settings of the entire project at the same time, but this action can be canceled.
+     */
+    ignoreProjectConfig?: boolean;
+    /**
+     * Configuration of all entries in the workspace
+     *
+     * @see {@link RawWorkspaceEntries}
+     */
+    entries?: RawWorkspaceEntries;
+    /**
+     * Hook Setting
+     * @see {@link UserHooks}
+     */
+    hooks?: UserHooks;
+    /**
+     * Plug-in List
+     * @see {@link UserPluginOption}
+     */
+    plugins?: UserPluginOption[];
+    /**
+     * d.ts output setting
+     * @see {@link DTSSettings}
+     */
+    dts?: DTSSettings;
+}
+/**
+ * Workspace Configuration
+ */
+interface ResolvedWorkspaceConfig extends Required<Omit<UserWorkspaceConfig, 'entries' | 'hooks' | 'plugins' | 'dts' | TSUpSyncOption>>, TSUpSyncOptions {
+    /**
+     * Configuration of all entries in the workspace
+     *
+     * @see {@link WorkspaceEntries}
+     */
+    entries: WorkspaceEntries;
+    /**
+     * Hook Setting
+     * @see {@link UserHooks}
+     */
+    hooks?: UserHooks;
+    /**
+     * Plug-in List
+     * @see {@link UserPluginOption}
+     */
+    plugins: Plugin[];
+    /**
+     * d.ts output setting
+     * @see {@link DTSSettings}
+     */
+    dts?: DTSSettings;
+}
+type WorkspacePackageJson = RequiredPackageJSON<WorkspaceRequiredField>;
+/**
+ * Workspace Directory Settings
+ */
+interface WorkspaceDirs {
+    /** Path instance of the source directory */
+    src: Path;
+    /** Path instance of the distribution directory */
+    dist: Path;
+}
+/**
+ * Workspace Meta Information
+ *
+ * @remarks This will be set to a value uniquely extended by the plugin
+ */
+interface WorkspaceMeta {
+}
+/**
+ * Workspace setup context object
+ * @remarks Objects that are configured when the workspace is set up. Customization can be done before the workspace instance is created by a plug-in or other process.
+ */
+interface WorkspaceSetupContext {
+    /** Workspace directory path instance */
+    dir: Path;
+    /** package.json */
+    json: WorkspacePackageJson;
+    /**
+     * Workspace Configuration
+     * @see {@link ResolvedWorkspaceConfig}
+     */
+    config: ResolvedWorkspaceConfig;
+    /** Plugboy Project */
+    project: PlugboyProject | null;
+    /** Workspace Directory Settings */
+    dirs: WorkspaceDirs;
+    /**
+     * All package names on which the workspace depends
+     */
+    dependencies: string[];
+    /**
+     * Names of all in-project packages on which the workspace depends
+     */
+    projectDependencies: string[];
+    /**
+     * Workspace Meta Information
+     * @see {@link WorkspaceMeta}
+     */
+    meta: WorkspaceMeta;
+    /**
+     * プラグインリスト
+     * @see {@link Plugin}
+     */
+    plugins: Plugin[];
+    /**
+     * Map of hook methods that can be initialized and called
+     * @see {@link BuildedHooks}
+     */
+    hooks: BuildedHooks;
+    /**
+     * d.ts output setting
+     * @see {@link NormalizedDTSSettings}
+     */
+    dts: NormalizedDTSSettings;
+}
+
+/** plugboy hook definition */
+interface HookTypes {
+    /**
+     * Hooks during workspace setup
+     * @remarks Called just before the workspace instance is created
+     * @param ctx - {@link WorkspaceSetupContext Workspace setup context object}
+     */
+    setupWorkspace: (ctx: WorkspaceSetupContext) => any;
+    /**
+     * Hooks after workspace generation
+     * @param workspace - {@link PlugboyWorkspace workspace instance}
+     */
+    createWorkspace: (workspace: PlugboyWorkspace) => any;
+    /**
+     * Hooks when correcting package.json
+     * @param json - package.json just before it was modified and saved by the plugboy
+     * @param workspace - {@link PlugboyWorkspace workspace instance}
+     */
+    preparePackageJSON: (json: WorkspacePackageJson, workspace: PlugboyWorkspace) => any;
+}
+declare function createHooksDefaults(): ResolvedHooks;
+type HookName = keyof HookTypes;
+/**
+ * plugboy user hook definition
+ * @see {@link HookTypes}
+ */
+type UserHooks = {
+    [Name in HookName]?: Listable<HookTypes[Name]>;
+};
+/**
+ * Pre-setup hook definitions
+ * @see {@link HookTypes}
+ */
+type ResolvedHooks = {
+    [Name in HookName]: HookTypes[Name][];
+};
+type HookArgs<Name extends HookName> = Parameters<HookTypes[Name]>;
+type UnPromisify<T> = T extends Promise<infer U> ? U : T;
+type HookReturnType<Name extends HookName> = UnPromisify<ReturnType<HookTypes[Name]>>;
+/**
+ * Map of hook methods that can be initialized and called
+ * @see {@link HookTypes}
+ */
+type BuildedHooks = {
+    [Name in HookName]: (...args: HookArgs<Name>) => Promise<HookReturnType<Name>>;
+};
+
+declare const PROJECT_REQUIRED_FIELDS: readonly ["name"];
+type ProjectRequiredField = (typeof PROJECT_REQUIRED_FIELDS)[number];
+type TSConfigJSON = {
+    compilerOptions?: CompilerOptions;
+} & Record<string, any>;
+/**
+ * Template for package.json script in workspace
+ */
+interface ProjectScriptsTemplate {
+    /** Template Name */
+    name: string;
+    /** Script Map */
+    scripts: Record<string, string>;
+}
+/**
+ * Project User Configuration
+ */
+interface UserProjectConfig {
+    /**
+     * Directory where the workspace is located
+     * @remarks Used to create a new workspace with the `plugboy gen` CLI command.
+     * @default packages
+     */
+    workspacesDir?: string;
+    /**
+     * Workspace script templates, or a list of them
+     * @remarks Used to create a new workspace with the `plugboy gen` CLI command.
+     */
+    scripts?: Record<string, string> | ProjectScriptsTemplate[];
+    /**
+     * Workspace tsconfig template
+     * @remarks Used to create a new workspace with the `plugboy gen` CLI command.
+     */
+    tsconfig?: TSConfigJSON;
+    /**
+     * Workspace README template
+     * @remarks Used to create a new workspace with the `plugboy gen` CLI command.
+     */
+    readme?: (json: WorkspacePackageJson) => string;
+    /**
+     * Fixes the version of all peer dependencies in the project
+     */
+    peerDependencies?: Record<string, string>;
+    /**
+     * Hook Setting
+     * @see {@link UserHooks}
+     */
+    hooks?: UserHooks;
+    /**
+     * Plug-in List
+     * @see {@link UserPluginOption}
+     */
+    plugins?: UserPluginOption[];
+    /**
+     * d.ts output setting
+     * @see {@link DTSSettings}
+     */
+    dts?: DTSSettings;
+}
+/**
+ * Project Configuration
+ */
+interface ResolvedProjectConfig extends Required<Omit<UserProjectConfig, 'scripts' | 'tsconfig' | 'hooks' | 'plugins' | 'dts'>> {
+    /**
+     * Workspace script templates list
+     * @remarks Used to create a new workspace with the `plugboy gen` CLI command.
+     */
+    scripts: ProjectScriptsTemplate[];
+    /**
+     * Workspace tsconfig template
+     * @remarks Used to create a new workspace with the `plugboy gen` CLI command.
+     */
+    tsconfig?: TSConfigJSON;
+    /**
+     * Hook Setting
+     * @see {@link UserHooks}
+     */
+    hooks?: UserHooks;
+    /**
+     * Plug-in List
+     * @see {@link UserPluginOption}
+     */
+    plugins: Plugin[];
+    /**
+     * d.ts output setting
+     * @see {@link DTSSettings}
+     */
+    dts?: DTSSettings;
+}
+type ProjectPackageJson = RequiredPackageJSON<ProjectRequiredField>;
+/**
+ * Project setup context object
+ * @remarks Objects that are configured when the project is set up.
+ */
+interface ProjectSetupContext {
+    /** Project directory path instance */
+    dir: Path;
+    /** package.json */
+    json: ProjectPackageJson;
+    /** Project Configuration */
+    config: ResolvedProjectConfig;
+    /**
+     * List of directory names of workspaces located in the project
+     * @remarks Note that it is the directory name, not the package name.
+     */
+    resolvedWorkspaces: string[];
+}
+
+interface GetProjectPackageJsonResult {
+    dir: Path;
+    json: ProjectPackageJson;
+}
+declare function getProjectPackageJson<AllowMissing extends boolean | undefined = false>(searchDir?: string, allowMissing?: AllowMissing): Promise<AllowMissing extends true ? GetProjectPackageJsonResult | null : GetProjectPackageJsonResult>;
+interface GetWorkspacePackageJsonResult {
+    dir: Path;
+    json: WorkspacePackageJson;
+}
+declare function getWorkspacePackageJson<AllowMissing extends boolean | undefined = false>(searchDir?: string, allowMissing?: AllowMissing): Promise<AllowMissing extends true ? GetWorkspacePackageJsonResult | null : GetWorkspacePackageJsonResult>;
+declare function findWorkspacePackages(dir: string): Promise<GetWorkspacePackageJsonResult[]>;
+
+export { BuildedHooks, Builder, DTSPreserveTypeSettings, DTSPreserveTypeTarget, DTSSettings, ESBuildPlugin, ESBuildPluginOption, FindConfigResult, GetProjectPackageJsonResult, GetWorkspacePackageJsonResult, HookArgs, HookName, HookReturnType, HookTypes, Listable, NormalizedDTSPreserveTypeSettings, NormalizedDTSPreserveTypeTarget, NormalizedDTSSettings, PROJECT_REQUIRED_FIELDS, Path, PlugboyProject, PlugboyWorkspace, Plugin, ProjectPackageJson, ProjectScriptsTemplate, ProjectSetupContext, RawWorkspaceEntries, RawWorkspaceEntry, RawWorkspaceEntryObject, ResolvedHooks, ResolvedProjectConfig, ResolvedWorkspaceConfig, TSConfigJSON, TSUP_SYNC_OPTIONS, UnPromisify, UserHooks, UserPluginOption, UserProjectConfig, UserWorkspaceConfig, WORKSPACE_PACKAGE_SYNC_FIELDS, WORKSPACE_REQUIRED_FIELDS, WorkspaceDirs, WorkspaceEntries, WorkspaceEntry, WorkspaceExport, WorkspaceMeta, WorkspaceObjectExport, WorkspacePackageJson, WorkspaceSetupContext, WorkspaceStubLink, WorkspaceStubLinkType, buildHooks, copyDirSync, createHooksDefaults, definePlugin, defineProjectConfig, defineWorkspaceConfig, extractProjectPlugins, findConfig, findFile, findProjectPlugin, findWorkspacePackages, generateWorkspace, getDirname, getFilename, getProject, getProjectPackageJson, getWorkspace, getWorkspacePackageJson, isFileNotFoundException, isProjectPackageJson, isPromise, isWorkspacePackageJson, loadProjectConfig, loadWorkspaceConfig, mergeDTSSettingsList, normalizeDTSPreserveTypeSettings, normalizeDTSPreserveTypeTarget, normalizeDTSSettings, pathExists, resolveListable, resolveRawWorkspaceEntries, resolveRawWorkspaceEntry, resolveUserHooks, resolveUserPluginOptions, resolveUserProjectConfig, resolveUserWorkspaceConfig, rmrf, syncWorkspacePackageFields };