@dagger.io/dagger 0.0.1-0

package/dist/src/module/introspector/dagger_module/enumClass.js

@@ -0,0 +1,69 @@
+import ts from "typescript";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST } from "../typescript_module/index.js";
+import { Locatable } from "./locatable.js";
+export class DaggerEnumClassValue extends Locatable {
+    node;
+    ast;
+    name;
+    value;
+    description;
+    deprecated;
+    symbol;
+    constructor(node, ast) {
+        super(node);
+        this.node = node;
+        this.ast = ast;
+        this.name = this.node.name.getText();
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        const { description, deprecated } = this.ast.getSymbolDoc(this.symbol);
+        this.description = description;
+        this.deprecated = deprecated;
+        const initializer = this.node.initializer;
+        if (!initializer) {
+            throw new Error("Dagger enum value has no value set");
+        }
+        this.value = this.ast.resolveParameterDefaultValue(initializer);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            value: this.value,
+            description: this.description,
+            deprecated: this.deprecated,
+        };
+    }
+}
+export class DaggerEnumClass extends Locatable {
+    node;
+    ast;
+    name;
+    description;
+    values = {};
+    symbol;
+    constructor(node, ast) {
+        super(node);
+        this.node = node;
+        this.ast = ast;
+        if (!this.node.name) {
+            throw new IntrospectionError(`could not resolve name of enum at ${AST.getNodePosition(node)}.`);
+        }
+        this.name = this.node.name.getText();
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        this.description = this.ast.getDocFromSymbol(this.symbol);
+        const properties = this.node.members;
+        for (const property of properties) {
+            if (ts.isPropertyDeclaration(property)) {
+                const value = new DaggerEnumClassValue(property, this.ast);
+                this.values[value.name] = value;
+            }
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            values: this.values,
+        };
+    }
+}

package/dist/src/module/introspector/dagger_module/function.d.ts

@@ -0,0 +1,39 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typedef.js";
+import { AST } from "../typescript_module/index.js";
+import { DaggerArguments } from "./argument.js";
+import { Locatable } from "./locatable.js";
+import { References } from "./reference.js";
+export type DaggerFunctions = {
+    [name: string]: DaggerFunction;
+};
+export declare class DaggerFunction extends Locatable {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    deprecated?: string;
+    private _returnTypeRef?;
+    returnType?: TypeDef<TypeDefKind>;
+    arguments: DaggerArguments;
+    alias: string | undefined;
+    cache: string | undefined;
+    isCheck: boolean;
+    private signature;
+    private symbol;
+    constructor(node: ts.MethodDeclaration, ast: AST);
+    private getReturnType;
+    getArgsOrder(): string[];
+    getReferences(): string[];
+    propagateReferences(references: References): void;
+    toJSON(): {
+        name: string;
+        description: string;
+        deprecated: string | undefined;
+        alias: string | undefined;
+        arguments: DaggerArguments;
+        returnType: TypeDef<TypeDefKind> | undefined;
+    };
+}
+//# sourceMappingURL=function.d.ts.map

package/dist/src/module/introspector/dagger_module/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAGxD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EACL,GAAG,EAGJ,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAkB,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/D,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,MAAM,MAAM,eAAe,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAA;CAAE,CAAA;AAEhE,qBAAa,cAAe,SAAQ,SAAS;IAezC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAff,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IAC1B,OAAO,CAAC,cAAc,CAAC,CAAQ;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;IACjC,SAAS,EAAE,eAAe,CAAK;IAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,OAAO,EAAE,OAAO,CAAQ;IAE/B,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,iBAAiB,EAC1B,GAAG,EAAE,GAAG;IAuC3B,OAAO,CAAC,aAAa;IAWd,YAAY,IAAI,MAAM,EAAE;IAIxB,aAAa,IAAI,MAAM,EAAE;IAoBzB,mBAAmB,CAAC,UAAU,EAAE,UAAU;IAuB1C,MAAM;;;;;;;;CAUd"}

package/dist/src/module/introspector/dagger_module/function.js

@@ -0,0 +1,102 @@
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST, isTypeDefResolved, resolveTypeDef, } from "../typescript_module/index.js";
+import { DaggerArgument } from "./argument.js";
+import { CHECK_DECORATOR, FUNCTION_DECORATOR } from "./decorator.js";
+import { Locatable } from "./locatable.js";
+export class DaggerFunction extends Locatable {
+    node;
+    ast;
+    name;
+    description;
+    deprecated;
+    _returnTypeRef;
+    returnType;
+    arguments = {};
+    alias;
+    cache;
+    isCheck = false;
+    signature;
+    symbol;
+    constructor(node, ast) {
+        super(node);
+        this.node = node;
+        this.ast = ast;
+        this.symbol = this.ast.getSymbolOrThrow(node.name);
+        this.signature = this.ast.getSignatureFromFunctionOrThrow(node);
+        this.name = this.node.name.getText();
+        const { description, deprecated } = this.ast.getSymbolDoc(this.symbol);
+        this.description = description;
+        this.deprecated = deprecated;
+        const functionArguments = this.ast.getDecoratorArgument(this.node, FUNCTION_DECORATOR, "object");
+        if (functionArguments) {
+            if (typeof functionArguments === "string") {
+                // previously only a single arg was accepted for alias, so if there's just
+                // a string we intrepret it that way for backward compatibility
+                this.alias = functionArguments;
+            }
+            else {
+                this.alias = functionArguments.alias;
+                this.cache = functionArguments.cache;
+            }
+        }
+        // Parse @check decorator
+        if (this.ast.isNodeDecoratedWith(this.node, CHECK_DECORATOR)) {
+            this.isCheck = true;
+        }
+        for (const parameter of this.node.parameters) {
+            this.arguments[parameter.name.getText()] = new DaggerArgument(parameter, this.ast);
+        }
+        this.returnType = this.getReturnType();
+    }
+    getReturnType() {
+        const type = this.signature.getReturnType();
+        const typedef = this.ast.tsTypeToTypeDef(this.node, type);
+        if (typedef === undefined || !isTypeDefResolved(typedef)) {
+            this._returnTypeRef = this.ast.typeToStringType(type);
+        }
+        return typedef;
+    }
+    getArgsOrder() {
+        return Object.keys(this.arguments);
+    }
+    getReferences() {
+        const references = [];
+        if (this._returnTypeRef &&
+            (this.returnType === undefined || !isTypeDefResolved(this.returnType))) {
+            references.push(this._returnTypeRef);
+        }
+        for (const argument of Object.values(this.arguments)) {
+            const reference = argument.getReference();
+            if (reference) {
+                references.push(reference);
+            }
+        }
+        return references;
+    }
+    propagateReferences(references) {
+        for (const argument of Object.values(this.arguments)) {
+            argument.propagateReferences(references);
+        }
+        if (!this._returnTypeRef) {
+            return;
+        }
+        if (this.returnType && isTypeDefResolved(this.returnType)) {
+            return;
+        }
+        const typeDef = references[this._returnTypeRef];
+        if (!typeDef) {
+            throw new IntrospectionError(`could not find type reference for ${this._returnTypeRef} at ${AST.getNodePosition(this.node)}.`);
+        }
+        this.returnType = resolveTypeDef(this.returnType, typeDef);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            deprecated: this.deprecated,
+            alias: this.alias,
+            arguments: this.arguments,
+            returnType: this.returnType,
+        };
+    }
+}

package/dist/src/module/introspector/dagger_module/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./constructor.js";
+export * from "./argument.js";
+export * from "./enum.js";
+export * from "./enumBase.js";
+export * from "./enumClass.js";
+export * from "./function.js";
+export * from "./module.js";
+export * from "./object.js";
+export * from "./objectBase.js";
+export * from "./reference.js";
+export * from "./typeObject.js";
+export * from "./decorator.js";
+export * from "./locatable.js";
+export * from "./interface.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/module/introspector/dagger_module/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA"}

package/dist/src/module/introspector/dagger_module/index.js

@@ -0,0 +1,14 @@
+export * from "./constructor.js";
+export * from "./argument.js";
+export * from "./enum.js";
+export * from "./enumBase.js";
+export * from "./enumClass.js";
+export * from "./function.js";
+export * from "./module.js";
+export * from "./object.js";
+export * from "./objectBase.js";
+export * from "./reference.js";
+export * from "./typeObject.js";
+export * from "./decorator.js";
+export * from "./locatable.js";
+export * from "./interface.js";

package/dist/src/module/introspector/dagger_module/interface.d.ts

@@ -0,0 +1,25 @@
+import ts from "typescript";
+import { AST } from "../typescript_module/index.js";
+import { DaggerInterfaceFunctions } from "./interfaceFunction.js";
+import { Locatable } from "./locatable.js";
+import { References } from "./reference.js";
+export type DaggerInterfaces = {
+    [name: string]: DaggerInterface;
+};
+export declare class DaggerInterface extends Locatable {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    functions: DaggerInterfaceFunctions;
+    private symbol;
+    constructor(node: ts.InterfaceDeclaration, ast: AST);
+    getReferences(): string[];
+    propagateReferences(references: References): void;
+    toJSON(): {
+        name: string;
+        description: string;
+        functions: DaggerInterfaceFunctions;
+    };
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/src/module/introspector/dagger_module/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAE,GAAG,EAAE,MAAM,+BAA+B,CAAA;AACnD,OAAO,EAEL,wBAAwB,EACzB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,MAAM,MAAM,gBAAgB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;CAAE,CAAA;AAElE,qBAAa,eAAgB,SAAQ,SAAS;IAO1C,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAPf,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,wBAAwB,CAAK;IAC/C,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,oBAAoB,EAC7B,GAAG,EAAE,GAAG;IAoCpB,aAAa,IAAI,MAAM,EAAE;IAQzB,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAMjD,MAAM;;;;;CAOd"}

package/dist/src/module/introspector/dagger_module/interface.js

@@ -0,0 +1,56 @@
+import ts from "typescript";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST } from "../typescript_module/index.js";
+import { DaggerInterfaceFunction, } from "./interfaceFunction.js";
+import { Locatable } from "./locatable.js";
+export class DaggerInterface extends Locatable {
+    node;
+    ast;
+    name;
+    description;
+    functions = {};
+    symbol;
+    constructor(node, ast) {
+        super(node);
+        this.node = node;
+        this.ast = ast;
+        if (!this.node.name) {
+            throw new IntrospectionError(`could not resolve name of interface at ${AST.getNodePosition(node)}`);
+        }
+        this.name = this.node.name.getText();
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        this.description = this.ast.getDocFromSymbol(this.symbol);
+        for (const member of this.node.members) {
+            if (!ts.isPropertySignature(member) && !ts.isMethodSignature(member)) {
+                continue;
+            }
+            // Check if it's a function
+            if ((member.type && ts.isFunctionTypeNode(member.type)) ||
+                ts.isMethodSignature(member)) {
+                const daggerInterfaceFunction = new DaggerInterfaceFunction(member, this.ast);
+                this.functions[daggerInterfaceFunction.name] = daggerInterfaceFunction;
+                continue;
+            }
+            // TODO(TomChv): Add support for fields
+        }
+    }
+    getReferences() {
+        const references = [];
+        for (const fn of Object.values(this.functions)) {
+            references.push(...fn.getReferences());
+        }
+        return references.filter((v, i, arr) => arr.indexOf(v) === i);
+    }
+    propagateReferences(references) {
+        for (const fn of Object.values(this.functions)) {
+            fn.propagateReferences(references);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            functions: this.functions,
+        };
+    }
+}

package/dist/src/module/introspector/dagger_module/interfaceFunction.d.ts

@@ -0,0 +1,35 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typedef.js";
+import { AST } from "../typescript_module/index.js";
+import { DaggerArguments } from "./argument.js";
+import { Locatable } from "./locatable.js";
+import { References } from "./reference.js";
+export type DaggerInterfaceFunctions = {
+    [name: string]: DaggerInterfaceFunction;
+};
+export declare class DaggerInterfaceFunction extends Locatable {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    deprecated?: string;
+    private _returnTypeRef?;
+    returnType?: TypeDef<TypeDefKind>;
+    arguments: DaggerArguments;
+    private symbol;
+    private signature?;
+    alias: undefined;
+    cache: undefined;
+    constructor(node: ts.PropertySignature | ts.MethodSignature, ast: AST);
+    getReferences(): string[];
+    propagateReferences(references: References): void;
+    toJSON(): {
+        name: string;
+        description: string;
+        deprecated: string | undefined;
+        arguments: DaggerArguments;
+        returnType: TypeDef<TypeDefKind> | undefined;
+    };
+}
+//# sourceMappingURL=interfaceFunction.d.ts.map

package/dist/src/module/introspector/dagger_module/interfaceFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaceFunction.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/interfaceFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EACL,GAAG,EAGJ,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAkB,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,MAAM,MAAM,wBAAwB,GAAG;IACrC,CAAC,IAAI,EAAE,MAAM,GAAG,uBAAuB,CAAA;CACxC,CAAA;AAED,qBAAa,uBAAwB,SAAQ,SAAS;IAelD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAff,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IAC1B,OAAO,CAAC,cAAc,CAAC,CAAQ;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;IACjC,SAAS,EAAE,eAAe,CAAK;IACtC,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAC,CAAc;IAGzB,KAAK,EAAE,SAAS,CAAA;IAChB,KAAK,EAAE,SAAS,CAAA;gBAGJ,IAAI,EAAE,EAAE,CAAC,iBAAiB,GAAG,EAAE,CAAC,eAAe,EAC/C,GAAG,EAAE,GAAG;IA6CpB,aAAa,IAAI,MAAM,EAAE;IAqBzB,mBAAmB,CAAC,UAAU,EAAE,UAAU;IAuB1C,MAAM;;;;;;;CASd"}

package/dist/src/module/introspector/dagger_module/interfaceFunction.js

@@ -0,0 +1,92 @@
+import ts from "typescript";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST, isTypeDefResolved, resolveTypeDef, } from "../typescript_module/index.js";
+import { DaggerArgument } from "./argument.js";
+import { Locatable } from "./locatable.js";
+export class DaggerInterfaceFunction extends Locatable {
+    node;
+    ast;
+    name;
+    description;
+    deprecated;
+    _returnTypeRef;
+    returnType;
+    arguments = {};
+    symbol;
+    signature;
+    // Just placeholders to be compatible with `Method` during registration
+    alias;
+    cache;
+    constructor(node, ast) {
+        super(node);
+        this.node = node;
+        this.ast = ast;
+        if (!this.node.name) {
+            throw new IntrospectionError(`could not resolve name of interface function at ${AST.getNodePosition(node)}`);
+        }
+        this.name = this.node.name.getText();
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        const { description, deprecated } = this.ast.getSymbolDoc(this.symbol);
+        this.description = description;
+        this.deprecated = deprecated;
+        // If it's a method signature, we can directly use it to get the signature props
+        // If it's a property kind signature, we need to get the signature from the type
+        // Examle:
+        // interface Foo {
+        //   bar(): void       // <- this is a method signature
+        //   baz: () => string // <- this is a property kind signature
+        // }
+        const nodeType = this.node.type && ts.isFunctionTypeNode(this.node.type)
+            ? this.node.type
+            : this.node;
+        const signature = this.ast.getSignatureFromFunctionOrThrow(nodeType);
+        for (const parameter of nodeType.parameters) {
+            this.arguments[parameter.name.getText()] = new DaggerArgument(parameter, this.ast);
+        }
+        const signatureReturnType = signature.getReturnType();
+        const typedef = this.ast.tsTypeToTypeDef(this.node, signatureReturnType);
+        if (typedef === undefined || !isTypeDefResolved(typedef)) {
+            this._returnTypeRef = this.ast.typeToStringType(signatureReturnType);
+        }
+        this.returnType = typedef;
+    }
+    getReferences() {
+        const references = [];
+        if (this._returnTypeRef &&
+            (this.returnType === undefined || !isTypeDefResolved(this.returnType))) {
+            references.push(this._returnTypeRef);
+        }
+        for (const argument of Object.values(this.arguments)) {
+            const reference = argument.getReference();
+            if (reference) {
+                references.push(reference);
+            }
+        }
+        return references;
+    }
+    propagateReferences(references) {
+        for (const argument of Object.values(this.arguments)) {
+            argument.propagateReferences(references);
+        }
+        if (!this._returnTypeRef) {
+            return;
+        }
+        if (this.returnType && isTypeDefResolved(this.returnType)) {
+            return;
+        }
+        const typeDef = references[this._returnTypeRef];
+        if (!typeDef) {
+            throw new IntrospectionError(`could not find type reference for ${this._returnTypeRef} at ${AST.getNodePosition(this.node)}.`);
+        }
+        this.returnType = resolveTypeDef(this.returnType, typeDef);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            deprecated: this.deprecated,
+            arguments: this.arguments,
+            returnType: this.returnType,
+        };
+    }
+}

package/dist/src/module/introspector/dagger_module/locatable.d.ts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+import { Location } from "../typescript_module/index.js";
+/**
+ * Locatable is a base class that any Dagger object can extend from to
+ * provide a location method.
+ */
+export declare class Locatable {
+    private readonly __node;
+    constructor(__node: ts.Node);
+    getLocation(): Location;
+}
+//# sourceMappingURL=locatable.d.ts.map

package/dist/src/module/introspector/dagger_module/locatable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locatable.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/locatable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAO,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAE7D;;;GAGG;AACH,qBAAa,SAAS;IACR,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,EAAE,CAAC,IAAI;IAE5C,WAAW,IAAI,QAAQ;CAGxB"}

package/dist/src/module/introspector/dagger_module/locatable.js

@@ -0,0 +1,14 @@
+import { AST } from "../typescript_module/index.js";
+/**
+ * Locatable is a base class that any Dagger object can extend from to
+ * provide a location method.
+ */
+export class Locatable {
+    __node;
+    constructor(__node) {
+        this.__node = __node;
+    }
+    getLocation() {
+        return AST.getNodeLocation(this.__node);
+    }
+}

package/dist/src/module/introspector/dagger_module/module.d.ts

@@ -0,0 +1,118 @@
+import Module from "node:module";
+import { AST } from "../typescript_module/index.js";
+import { DaggerEnumsBase } from "./enumBase.js";
+import { DaggerInterfaces } from "./interface.js";
+import { DaggerObjectsBase } from "./objectBase.js";
+/**
+ * DaggerModule represents a TypeScript module with a set of files
+ * with Dagger object conversion and notation.
+ *
+ * It starts from the module entrypoint (the class named the same as the module) and
+ * then recursively resolve every references to other declared identifiers.
+ * After resolution, it propagates all the references to the modules declarations
+ * and finally it generates the final Dagger module representation.
+ */
+export declare class DaggerModule {
+    name: string;
+    private userModule;
+    private ast;
+    /**
+     * An object is either a decorated class or a type alias object.
+     * Type alias objects cannot be decorated so they are resolved if referenced in the module.
+     *
+     * @example
+     * ```ts
+     * @object()
+     * export class MyObject {
+     *  @func()
+     *  public name: string
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * export type Example = {
+     *   name: string
+     * }
+     * ```
+     */
+    objects: DaggerObjectsBase;
+    /**
+     * An enum is typically a native TypeScript enum declared with the `enum` keyword.
+     * Decorated classes using `@enumType()` are still supported for backward compatibility.
+     *
+     * @example
+     * ```ts
+     * export enum Example {
+     *   A = "a",
+     *   B = "b",
+     * }
+     * ```
+     */
+    enums: DaggerEnumsBase;
+    /**
+     * An interface is declared using the `interface` keyword.
+     *
+     * @example
+     * ```ts
+     * export interface Example {
+     *   foo: (): string
+     *   asyncFoo: (): Promise<string>
+     * }
+     * ```
+     */
+    interfaces: DaggerInterfaces;
+    description: string | undefined;
+    private references;
+    constructor(name: string, userModule: Module[], ast: AST);
+    /**
+     * Find the reference of the module and register it to the module references.
+     *
+     * To do so, we check the user module to find a corresponding symbol (name) for each of
+     * typedef we support.
+     * This only applies for:
+     * - classes
+     * - enums
+     * - scalars
+     * - interfaces
+     *
+     * If the reference is an object, a class or an interface, recursively find the references of the object.
+     *
+     * *Note*: If a class is referenced but not exported and not decorated with `@object()`, we throw an error
+     * because we aim to be explicit. (TomChv: Should we change this behaviour?)
+     */
+    private resolveReferences;
+    /**
+     * Resolve type alias to the corresponding TypeDef.
+     * A type might refer to anything typeable in TypeScript but right now we supports:
+     * - `type Example = string`
+     * - `type Example = { prop: string}`
+     * - `type Example = number`
+     * - `type Example = boolean`
+     * - `type Example = void`
+     *
+     * If the reference is an object, we recursively resolve its references.
+     * If the type cannot be resolved or is not supported, we throw an error.
+     */
+    private resolveTypeAlias;
+    /**
+     * Find the classes in the AST. Returns only our main class if it exists
+     */
+    private findClasses;
+    /**
+     * Recursively propagate references to all objects properties and functions.
+     */
+    private propagateReferences;
+    /**
+     * Get the top level comment of the file that contains the module entrypoint.
+     */
+    private getDescription;
+    toJSON(): {
+        name: string;
+        description: string | undefined;
+        objects: DaggerObjectsBase;
+        enums: DaggerEnumsBase;
+        interfaces: DaggerInterfaces;
+    };
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/src/module/introspector/dagger_module/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/module.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,aAAa,CAAA;AAKhC,OAAO,EACL,GAAG,EAGJ,MAAM,+BAA+B,CAAA;AAGtC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/C,OAAO,EAAmB,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAElE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAInD;;;;;;;;GAQG;AACH,qBAAa,YAAY;IA4Dd,IAAI,EAAE,MAAM;IACnB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,GAAG;IA7Db;;;;;;;;;;;;;;;;;;;OAmBG;IACI,OAAO,EAAE,iBAAiB,CAAK;IAEtC;;;;;;;;;;;OAWG;IACI,KAAK,EAAE,eAAe,CAAK;IAElC;;;;;;;;;;OAUG;IACI,UAAU,EAAE,gBAAgB,CAAK;IAEjC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAEtC,OAAO,CAAC,UAAU,CAKjB;gBAGQ,IAAI,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAAE,EACpB,GAAG,EAAE,GAAG;IAuBlB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,iBAAiB;IAkIzB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IAsExB;;OAEG;IACH,OAAO,CAAC,WAAW;IA2BnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAgBtB,MAAM;;;;;;;CASP"}