@decohere/forge 0.0.1-dev.5

package/types/src/types/build-target.type.d.ts

@@ -0,0 +1,7 @@
+export declare const BuildTargets: {
+    commonjs: "commonjs";
+    es6: "es6";
+    types: "types";
+};
+export type BuildTarget = "es6" | "commonjs" | "types";
+export type TranspileTarget = Exclude<BuildTarget, "types">;

package/types/src/types/configuration.type.d.ts

@@ -0,0 +1,6 @@
+import type { Configuration } from "@decohere/mesh";
+import type { BuildTarget } from "./build-target.type.js";
+export type ForgeConfiguration = Configuration & {
+    targets: BuildTarget[];
+    aliasPaths?: boolean;
+};

package/types/src/types/dependency.types.d.ts

@@ -0,0 +1,39 @@
+import type { ResultStatus } from "@decohere/nexus/cli";
+export type Package = {
+    name: string;
+    version?: string;
+    isInternal?: boolean;
+    isDev?: boolean;
+};
+export type ResolvedDependency = {
+    name: string;
+    version: string;
+    internal: boolean;
+    missing: false;
+    isDev: boolean;
+} | {
+    name: string;
+    version: undefined;
+    internal: undefined;
+    missing: true;
+    isDev: false;
+};
+export type SyncprojectResult = ResultStatus & {
+    projectName: string;
+    drift?: DriftEntry | null;
+};
+export type DriftEntry = {
+    original: {
+        dependencies: Record<string, string>;
+        devDependencies: Record<string, string>;
+    };
+    updated: {
+        dependencies: Record<string, string>;
+        devDependencies: Record<string, string>;
+    };
+};
+export type DependencyWarning = {
+    file: string;
+    line: number;
+    message: string;
+};

package/types/src/types/swc-config.type.d.ts

@@ -0,0 +1,9 @@
+import type { Tsconfig } from "@decohere/mesh";
+export type SwcConfigOptions = {
+    aliasPaths?: boolean;
+    tsConfig?: Tsconfig;
+    userConfig?: SwcConfig;
+};
+export declare class SwcConfig {
+    constructor(data?: Partial<SwcConfig>);
+}

package/types/src/types/transform-response.model.d.ts

@@ -0,0 +1,54 @@
+import type { Project } from "@decohere/mesh";
+import type { File } from "@decohere/nexus/io";
+import type { BuildTarget } from "./build-target.type.js";
+export type TransformOutcome = "success" | "failure" | "skipped";
+export declare const TransformOutcomes: {
+    success: "success";
+    failure: "failure";
+    skipped: "skipped";
+};
+type TransformResponseBase = {
+    file: File;
+    config: unknown;
+    project?: Project;
+    /** Absolute directory that will contain the output file. Pre-computed by the transformer. */
+    outputDir?: string;
+    /** Absolute path of the output file (outputDir + fileName). Pre-computed by the transformer. */
+    outputPath?: string;
+};
+type TransformSuccess = TransformResponseBase & {
+    outcome: "success";
+    code: string;
+    messages?: string[];
+    target: BuildTarget;
+    fileName: string;
+};
+type TransformFailure = TransformResponseBase & {
+    outcome: "failure";
+    messages?: string[];
+    target?: BuildTarget;
+    fileName?: string;
+};
+type TransformSkipped = TransformResponseBase & {
+    outcome: "skipped";
+    messages?: string | string[];
+};
+type TransformResponseData<T extends TransformOutcome = TransformOutcome> = T extends "success" ? TransformSuccess : T extends "skipped" ? TransformSkipped : TransformFailure;
+export declare class TransformResponse {
+    static Success(data: Omit<TransformResponseData<"success">, "outcome">): TransformResponse;
+    static Error(data: Omit<TransformResponseData<"failure">, "outcome">): TransformResponse;
+    static Skipped(data: Omit<TransformResponseData<"skipped">, "outcome">): TransformResponse;
+    static from(data: TransformResponseData): TransformResponse;
+    constructor(data?: Partial<TransformResponseData>);
+    readonly file: File;
+    readonly outcome: TransformOutcome;
+    readonly target?: BuildTarget;
+    readonly code: string;
+    readonly fileName?: string;
+    readonly messages?: string[];
+    readonly config: unknown;
+    readonly project?: Project;
+    readonly outputDir?: string;
+    readonly outputPath?: string;
+}
+export {};

package/types/src/types/transformer.type.d.ts

@@ -0,0 +1,37 @@
+import type { Project, Workspace } from "@decohere/mesh";
+import type { FileEx } from "@decohere/nexus/io";
+import type { Observable } from "rxjs";
+import type { BuildTarget } from "../types/build-target.type.js";
+import type { TransformResponse } from "./transform-response.model.js";
+export type FileEvent = {
+    type: "changed" | "added";
+    file: FileEx;
+    project?: Project;
+} | {
+    type: "deleted";
+    file: FileEx;
+    project: Project;
+};
+export declare const TransformerKey: unique symbol;
+export interface Transformer {
+    readonly buildTargets: BuildTarget[];
+    /**
+     * Optional pre-build phase that runs sequentially before all transformers'
+     * {@link transformProject} calls. Use for expensive CPU-bound setup (e.g.
+     * TypeScript createProgram) that must not compete with other transformers'
+     * parallel workloads.
+     */
+    init?(projects: Project | Project[], fileFilter?: (project: Project) => Promise<FileEx[]>): Promise<void>;
+    transformProject(projects: Project | Project[], fileFilter?: (project: Project) => Promise<FileEx[]>, onOutput?: (response: TransformResponse) => void): Promise<TransformResponse[]>;
+    /**
+     * If implemented, signals this transformer supports incremental (watch) mode.
+     * {@link BuildAction} calls this after the initial build, passing the workspace
+     * so the transformer can self-subscribe to file change events.
+     */
+    watch?(workspace: Workspace): void;
+    /**
+     * Emits incremental transform results after each file-change cycle.
+     * Present when {@link watch} is implemented.
+     */
+    incrementalTransform$?: Observable<TransformResponse[]>;
+}

package/types/src/types/workspace-config.type.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectOptions as BaseProjectOptions, WorkspaceOptions as BaseWorkspaceOptions } from "@decohere/mesh";
+import type { Action, CommandType } from "@decohere/nexus/cli";
+import type { Constructable } from "@decohere/nexus/reflection";
+import type { ForgeConfiguration } from "./configuration.type.js";
+export type ProjectOptions = Omit<BaseProjectOptions, "configurations"> & {
+    configurations: ForgeConfiguration[];
+};
+export type WorkspaceOptions = Omit<BaseWorkspaceOptions, "configurations" | "projects"> & {
+    configurations: ForgeConfiguration[];
+    projects?: Record<string, Partial<ProjectOptions>>;
+    actions?: Record<string, Constructable<Action>>;
+    commands?: Record<string, CommandType>;
+};

package/types/src/vitest/forge-build.plugin.d.ts

@@ -0,0 +1,18 @@
+export type ForgeBuildOptions = {
+    buildConfig?: string;
+    logLevel?: string;
+    workspaceRoot?: string;
+    /** Skip the build pre-warm entirely (e.g. when a pre-built artifact is already on disk). */
+    skipBuild?: boolean;
+};
+export declare function forgeBuild(options?: ForgeBuildOptions): {
+    name: string;
+    enforce: "pre";
+    configResolved(): void;
+    resolveId(source: string, importer: string | undefined): string | null;
+    watchChange(id: string): void;
+    transform(code: string, id: string): Promise<{
+        code: string;
+        map: string | null;
+    } | null>;
+};

package/types/src/vitest/index.d.ts

@@ -0,0 +1,2 @@
+export type { ForgeBuildOptions } from "./forge-build.plugin.js";
+export { forgeBuild } from "./forge-build.plugin.js";

package/types/src/workspace.config.d.ts

@@ -0,0 +1,6 @@
+import type { ForgeConfiguration } from "./types/configuration.type.js";
+import type { WorkspaceOptions } from "./types/workspace-config.type.js";
+export declare const Debug: ForgeConfiguration;
+export declare const Release: ForgeConfiguration;
+export declare const DefaultConfigurations: ForgeConfiguration[];
+export declare const WorkspaceDefaults: WorkspaceOptions;