@shd101wyy/yo 0.0.27 → 0.0.29

package/out/types/src/build-runner.d.ts

@@ -0,0 +1,22 @@
+import { BuildRegistry } from "./evaluator/builtins/build";
+export interface BuildOptions {
+    buildFile: string;
+    targetTriple?: string;
+    verbose?: boolean;
+    dryRun?: boolean;
+    listSteps?: boolean;
+    steps?: string[];
+    defines?: Record<string, string>;
+    cCompiler?: string;
+    sysroot?: string;
+    summary?: boolean;
+}
+export declare function runBuild(options: BuildOptions): Promise<void>;
+export interface DAGNode {
+    name: string;
+    kind: "artifact" | "test" | "run" | "step";
+    dependsOn: string[];
+}
+export declare function buildDAG(registry: BuildRegistry, rootStepName: string): DAGNode[];
+export declare function detectCycle(dag: DAGNode[]): string[] | null;
+export declare function computeDependencyHash(registry: BuildRegistry, depName: string, projectDir: string): string;

package/out/types/src/cache.d.ts

@@ -0,0 +1,3 @@
+export declare function getGlobalCacheDir(): string;
+export declare function getGlobalDepsCacheDir(): string;
+export declare function ensureGlobalDepsCacheDir(): string;

package/out/types/src/codegen/codegen-c.d.ts

@@ -1,12 +1,15 @@
 import type { ModuleValue } from "../value";
 export declare class CodeGeneratorC {
     private emitter;
+    private exportedFunctionNames;
     constructor();
     compileModule(modulePath: string, moduleValue: ModuleValue, options?: {
         debugGc?: boolean;
         debugParallelism?: boolean;
         debugAsyncAwait?: boolean;
         allocator?: "mimalloc" | "libc";
+        isLibrary?: boolean;
     }): void;
     print(): string;
+    getExportedFunctionNames(): Set<string>;
 }

package/out/types/src/codegen/index.d.ts

@@ -5,6 +5,8 @@ export declare class CodeGenerator {
         output: string;
         cCompiler: string;
         target: "c";
+        targetTriple?: string;
+        sysroot?: string;
         extern: string[];
         includePaths?: string[];
         libraryPaths?: string[];
@@ -23,6 +25,8 @@ export declare class CodeGenerator {
         debugSymbols?: boolean;
         strip?: boolean;
         static?: boolean;
+        shared?: boolean;
+        staticLibrary?: boolean;
         cflags?: string;
     }): void;
 }

package/out/types/src/codegen/utils/index.d.ts

@@ -77,6 +77,9 @@ export interface CodeGenContext {
     currentContinueLabel?: string;
     insideMatch?: boolean;
     typeIdStatics?: Map<string, string>;
+    isLibrary?: boolean;
+    currentModuleId?: string;
+    exportedFunctionLabels?: Map<FuncValueId, string>;
 }
 export declare function sanitizeForCIdentifier(str: string, isExternC?: boolean): string;
 export declare function shouldAvoidConst(type: Type): boolean;

package/out/types/src/evaluator/builtins/build.d.ts

@@ -0,0 +1,135 @@
+import type { Environment } from "../../env";
+import { type FnCallExpr } from "../../expr";
+import type { EvaluatorContext } from "../context";
+export interface BuildProject {
+    name: string;
+    root: string;
+}
+export interface BuildArtifact {
+    kind: "executable" | "static_library" | "shared_library";
+    name: string;
+    root: string;
+    target: string;
+    optimize: string;
+    allocator: string;
+    sanitize: string;
+    linkLibraries: string[];
+    includePaths: string[];
+    libraryPaths: string[];
+    cSources: string[];
+    cFlags: string[];
+    defines: string[];
+    strip: boolean;
+    staticLink: boolean;
+    linkedArtifacts: string[];
+    linkedSystemLibraries: string[];
+}
+export interface BuildTestSuite {
+    name: string;
+    root: string;
+    target: string;
+    verbose: boolean;
+    bail: boolean;
+    parallel: number;
+}
+export interface BuildRunStep {
+    name: string;
+    artifactName: string;
+    args: string[];
+}
+export interface BuildStep {
+    name: string;
+    description: string;
+    dependencyNames: string[];
+}
+export interface BuildGitDependency {
+    name: string;
+    url: string;
+    ref: string;
+    path: string;
+}
+export interface BuildPathDependency {
+    name: string;
+    path: string;
+}
+export interface BuildSystemLibrary {
+    name: string;
+    pkgConfig: string;
+    fallbackInclude: string;
+    fallbackLib: string;
+    fallbackLink: string;
+}
+export interface DependencyArtifactRef {
+    dependencyName: string;
+    artifactName: string;
+}
+export declare class BuildRegistry {
+    project: BuildProject | undefined;
+    artifacts: BuildArtifact[];
+    testSuites: BuildTestSuite[];
+    runSteps: BuildRunStep[];
+    steps: BuildStep[];
+    dependencies: BuildGitDependency[];
+    pathDependencies: BuildPathDependency[];
+    systemLibraries: BuildSystemLibrary[];
+    dependencyArtifacts: DependencyArtifactRef[];
+    cliOptions: Map<string, string>;
+    declaredOptions: Map<string, {
+        description: string;
+        defaultValue: string;
+    }>;
+    setCliOptions(options: Map<string, string>): void;
+    registerProject(name: string, root: string): void;
+    registerExecutable(config: Omit<BuildArtifact, "kind">): void;
+    registerStaticLibrary(config: Omit<BuildArtifact, "kind">): void;
+    registerSharedLibrary(config: Omit<BuildArtifact, "kind">): void;
+    registerTest(config: BuildTestSuite): void;
+    registerRun(artifactName: string, args: string[]): void;
+    registerStep(name: string, description: string, dependencyNames?: string[]): void;
+    addStepDependency(stepName: string, depName: string): void;
+    registerDependency(dep: BuildGitDependency): void;
+    registerPathDependency(dep: BuildPathDependency): void;
+    registerSystemLibrary(lib: BuildSystemLibrary): void;
+    registerDependencyArtifact(ref: DependencyArtifactRef): void;
+    registerLink(artifactName: string, libraryName: string): void;
+    findArtifact(name: string): BuildArtifact | undefined;
+    findTest(name: string): BuildTestSuite | undefined;
+    findRunStep(name: string): BuildRunStep | undefined;
+    findStep(name: string): BuildStep | undefined;
+    findDependency(name: string): BuildGitDependency | undefined;
+    findPathDependency(name: string): BuildPathDependency | undefined;
+    findSystemLibrary(name: string): BuildSystemLibrary | undefined;
+    getStepNames(): string[];
+    resolveDependency(name: string): {
+        kind: "artifact";
+        value: BuildArtifact;
+    } | {
+        kind: "test";
+        value: BuildTestSuite;
+    } | {
+        kind: "run";
+        value: BuildRunStep;
+    } | {
+        kind: "step";
+        value: BuildStep;
+    } | undefined;
+    resolveDependencies(step: BuildStep): {
+        artifacts: BuildArtifact[];
+        tests: BuildTestSuite[];
+        runs: BuildRunStep[];
+    };
+    clear(): void;
+}
+export declare function getRootBuildProjectDir(): string | undefined;
+export declare function setRootBuildProjectDir(dir: string | undefined): void;
+export declare function getDependencyProjectRoot(depDir: string): string | undefined;
+export declare function setDependencyProjectRoot(depDir: string, root: string): void;
+export declare function clearDependencyProjectRoots(): void;
+export declare function getBuildRegistry(): BuildRegistry;
+export declare function clearBuildRegistry(): void;
+export declare function swapBuildRegistry(newRegistry: BuildRegistry | undefined): BuildRegistry | undefined;
+export declare function evaluateYoBuildFunctions({ expr, env, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;

package/out/types/src/expr.d.ts

@@ -531,6 +531,23 @@ export declare const BuiltinFunctions: {
     __yo_maybe_uninit_assume_init: string[];
     __yo_process_platform: string[];
     __yo_process_arch: string[];
+    __yo_build_project: string[];
+    __yo_build_executable: string[];
+    __yo_build_static_library: string[];
+    __yo_build_shared_library: string[];
+    __yo_build_test: string[];
+    __yo_build_run: string[];
+    __yo_build_step: string[];
+    __yo_build_step_depend_on: string[];
+    __yo_build_link: string[];
+    __yo_build_link_system_library: string[];
+    __yo_build_target_host: string[];
+    __yo_build_target_parse: string[];
+    __yo_build_dependency: string[];
+    __yo_build_path_dependency: string[];
+    __yo_build_system_library: string[];
+    __yo_build_option: string[];
+    __yo_build_dep_artifact: string[];
 };
 export declare function exprIsInfixOperatorFunctionCall(expr: Expr): boolean;
 export interface ExprToStringConfig {

package/out/types/src/fetch-command.d.ts

@@ -0,0 +1,6 @@
+export interface FetchOptions {
+    buildFile: string;
+    verbose: boolean;
+    update: boolean;
+}
+export declare function runFetch(options: FetchOptions): Promise<void>;

package/out/types/src/fetch.d.ts

@@ -0,0 +1,10 @@
+import type { BuildGitDependency } from "./evaluator/builtins/build";
+import { type LockFile } from "./lock-file";
+export declare function getCacheDir(_projectDir?: string): string;
+export interface FetchResult {
+    resolvedPaths: Map<string, string>;
+    lockFile: LockFile;
+}
+export declare function fetchAllDependencies(projectDir: string, dependencies: BuildGitDependency[], verbose?: boolean, update?: boolean): FetchResult;
+export declare function areDependenciesCached(projectDir: string, dependencies: BuildGitDependency[]): boolean;
+export declare function resolveDependencyPath(projectDir: string, depName: string, depPath?: string): string | undefined;

package/out/types/src/init.d.ts

@@ -0,0 +1,5 @@
+export interface InitOptions {
+    dir: string;
+    name?: string;
+}
+export declare function initProject(options: InitOptions): void;

package/out/types/src/install-command.d.ts

@@ -0,0 +1,6 @@
+export interface InstallOptions {
+    package: string;
+    buildFile: string;
+    verbose: boolean;
+}
+export declare function runInstall(options: InstallOptions): Promise<void>;

package/out/types/src/lock-file.d.ts

@@ -0,0 +1,16 @@
+export interface LockEntry {
+    name: string;
+    url: string;
+    ref: string;
+    commit: string;
+    hash: string;
+}
+export interface LockFile {
+    dependencies: LockEntry[];
+}
+export declare function parseLockFile(content: string): LockFile;
+export declare function writeLockFileContent(lockFile: LockFile): string;
+export declare function readLockFile(projectDir: string): LockFile;
+export declare function saveLockFile(projectDir: string, lockFile: LockFile): void;
+export declare function findLockEntry(lockFile: LockFile, name: string): LockEntry | undefined;
+export declare function upsertLockEntry(lockFile: LockFile, entry: LockEntry): LockFile;

package/out/types/src/module-manager.d.ts

@@ -28,12 +28,14 @@ export declare class ModuleManager {
         moduleError: Error | undefined;
     };
     deleteModule(modulePath: string): void;
-    compileModule(modulePath: string, { emitC, debugGc, debugParallelism, debugAsyncAwait, allocator, }?: {
+    compileModule(modulePath: string, { emitC, debugGc, debugParallelism, debugAsyncAwait, allocator, isLibrary, }?: {
         emitC?: boolean;
         debugGc?: boolean;
         debugParallelism?: boolean;
         debugAsyncAwait?: boolean;
         allocator?: "mimalloc" | "libc";
+        isLibrary?: boolean;
     }): void;
     getGeneratedCode(): string;
+    getExportedFunctionNames(): Set<string>;
 }

package/out/types/src/pkg-config.d.ts

@@ -0,0 +1,11 @@
+import type { BuildSystemLibrary } from "./evaluator/builtins/build";
+export interface PkgConfigResult {
+    cFlags: string[];
+    ldFlags: string[];
+    includePaths: string[];
+    libraryPaths: string[];
+    linkLibraries: string[];
+}
+export declare function isPkgConfigAvailable(): boolean;
+export declare function resolveSystemLibrary(lib: BuildSystemLibrary, verbose?: boolean): PkgConfigResult;
+export declare function resolveAllSystemLibraries(libraries: BuildSystemLibrary[], verbose?: boolean): PkgConfigResult;

package/out/types/src/target.d.ts

@@ -0,0 +1,28 @@
+export type Arch = "x86_64" | "aarch64" | "x86" | "arm" | "wasm32";
+export type Os = "linux" | "macos" | "windows" | "freebsd" | "wasi";
+export type Abi = "gnu" | "musl" | "msvc" | "none" | "wasm";
+export interface TargetInfo {
+    arch: Arch;
+    os: Os;
+    abi: Abi | undefined;
+    pointerSizeBits: 32 | 64;
+    triple: string;
+}
+export interface HostInfo {
+    platform: Os;
+    arch: Arch;
+}
+export declare function pointerSizeForArch(arch: Arch): 32 | 64;
+export declare function detectHost(): HostInfo;
+export declare function hostTarget(): TargetInfo;
+export declare function parseTarget(triple: string): TargetInfo;
+export declare function clangTriple(target: TargetInfo): string;
+export declare function setCurrentTarget(target: TargetInfo): void;
+export declare function getCurrentTarget(): TargetInfo;
+export declare function targetOsToYoString(os: Os): string;
+export declare function targetArchToYoString(arch: Arch): string;
+export declare function isTargetWindows(target: TargetInfo): boolean;
+export declare function isTargetLinux(target: TargetInfo): boolean;
+export declare function isTargetMacos(target: TargetInfo): boolean;
+export declare function isTargetMSVC(target: TargetInfo): boolean;
+export declare function isTargetWasm(target: TargetInfo): boolean;

package/out/types/src/tests/build-system.test.d.ts

@@ -0,0 +1 @@
+export {};