@dagger.io/dagger 0.10.1 → 0.10.2

package/dist/entrypoint/register.js

@@ -2,33 +2,33 @@ import { dag, TypeDefKind, } from "../api/client.gen.js";
 /**
  * Register the module files and returns its ID
  */
-export async function register(files, scanResult) {
+export async function register(files, module) {
     // Get a new module that we will fill in with all the types
     let mod = dag.module_();
     // Add module description if any.
-    if (scanResult.module.description) {
-        mod = mod.withDescription(scanResult.module.description);
+    if (module.description) {
+        mod = mod.withDescription(module.description);
     }
     // For each class scanned, register its type, method and properties in the module.
-    Object.values(scanResult.classes).forEach((modClass) => {
+    Object.values(module.objects).forEach((object) => {
         // Register the class Typedef object in Dagger
-        let typeDef = dag.typeDef().withObject(modClass.name, {
-            description: modClass.description,
+        let typeDef = dag.typeDef().withObject(object.name, {
+            description: object.description,
         });
         // Register all functions (methods) to this object
-        Object.values(modClass.methods).forEach((method) => {
-            typeDef = typeDef.withFunction(addFunction(method));
+        Object.values(object.methods).forEach((method) => {
+            typeDef = typeDef.withFunction(addFunction(method.typeDef));
         });
         // Register all fields that belong to this object
-        Object.values(modClass.fields).forEach((field) => {
+        Object.values(object.properties).forEach((field) => {
             if (field.isExposed) {
-                typeDef = typeDef.withField(field.alias ?? field.name, addTypeDef(field.typeDef), {
+                typeDef = typeDef.withField(field.alias ?? field.name, addTypeDef(field.typeDef.typeDef), {
                     description: field.description,
                 });
             }
         });
-        if (modClass.constructor) {
-            typeDef = typeDef.withConstructor(addConstructor(modClass.constructor, typeDef));
+        if (object._constructor) {
+            typeDef = typeDef.withConstructor(addConstructor(object._constructor.typeDef, typeDef));
         }
         // Add it to the module object
         mod = mod.withObject(typeDef);

package/dist/introspector/scanner/abtractions/argument.d.ts

@@ -0,0 +1,75 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { FunctionArgTypeDef, TypeDef } from "../typeDefs.js";
+export type Arguments = {
+    [name: string]: Argument;
+};
+/**
+ * Argument is an abstraction of a function argument.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export declare class Argument {
+    private symbol;
+    private checker;
+    private param;
+    /**
+     * Create a new Argument instance.
+     *
+     * @param checker Checker to use to introspect the type of the argument.
+     * @param param The symbol of the argument to introspect.
+     *
+     * @throws UnknownDaggerError If the symbol doesn't have any declaration.
+     * @throws UnknownDaggerError If the declaration of the symbol isn't a parameter.
+     */
+    constructor(checker: ts.TypeChecker, param: ts.Symbol);
+    get name(): string;
+    get description(): string;
+    /**
+     * Return the type of the argument in a Dagger TypeDef format.
+     */
+    get type(): TypeDef<TypeDefKind>;
+    get defaultValue(): string | undefined;
+    /**
+     * Return true if the parameter is optional.
+     *
+     * A parameter is considered optional if he fits one of the following:
+     * - It has a question token (e.g. `foo?: <type>`).
+     * - It's variadic (e.g. `...foo: <type>[]`).
+     * - It's nullable (e.g. `foo: <type> | null`).
+     */
+    get isOptional(): boolean;
+    /**
+     * Return true if the parameter is nullable.
+     *
+     * A parameter is considered nullable if itstype is a union type with `null`
+     * on the list of types.
+     * Example: `foo: string | null`.
+     */
+    get isNullable(): boolean;
+    get isVariadic(): boolean;
+    get typeDef(): FunctionArgTypeDef;
+    toJSON(): {
+        name: string;
+        description: string;
+        type: TypeDef<TypeDefKind>;
+        isVariadic: boolean;
+        isNullable: boolean;
+        isOptional: boolean;
+        defaultValue: string | undefined;
+    };
+    /**
+     * The TypeScript Compiler API returns the raw default value as it is written
+     * by the user.
+     * However, some notations are not supported by GraphQL so this function
+     * formats the default value to be compatible with the GraphQL syntax.
+     *
+     * Formatting rules:
+     * - Single quote strings are converted to double quote strings.
+     *
+     * @param value The value to format.
+     */
+    private formatDefaultValue;
+}
+//# sourceMappingURL=argument.d.ts.map

package/dist/introspector/scanner/abtractions/argument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/argument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAI5D,MAAM,MAAM,SAAS,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAA;AAEpD;;;;;GAKG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAW;IAEzB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,KAAK,CAAyB;IAEtC;;;;;;;;OAQG;gBACS,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM;IAuBrD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,CAgB/B;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,SAAS,CAMrC;IAED;;;;;;;OAOG;IACH,IAAI,UAAU,IAAI,OAAO,CAMxB;IAED;;;;;;OAMG;IACH,IAAI,UAAU,IAAI,OAAO,CAcxB;IAED,IAAI,UAAU,IAAI,OAAO,CAExB;IAID,IAAI,OAAO,IAAI,kBAAkB,CAShC;IAED,MAAM;;;;;;;;;IAYN;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kBAAkB;CAU3B"}

package/dist/introspector/scanner/abtractions/argument.js

@@ -0,0 +1,137 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { serializeType } from "../serialize.js";
+import { typeNameToTypedef } from "../utils.js";
+/**
+ * Argument is an abstraction of a function argument.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export class Argument {
+    symbol;
+    checker;
+    param;
+    /**
+     * Create a new Argument instance.
+     *
+     * @param checker Checker to use to introspect the type of the argument.
+     * @param param The symbol of the argument to introspect.
+     *
+     * @throws UnknownDaggerError If the symbol doesn't have any declaration.
+     * @throws UnknownDaggerError If the declaration of the symbol isn't a parameter.
+     */
+    constructor(checker, param) {
+        this.symbol = param;
+        this.checker = checker;
+        const declarations = this.symbol.getDeclarations();
+        if (!declarations || declarations.length < 0) {
+            throw new UnknownDaggerError(`could not find param declarations of symbol ${this.symbol.name}`, {});
+        }
+        const parameterDeclaration = declarations[0];
+        if (!ts.isParameter(parameterDeclaration)) {
+            throw new UnknownDaggerError(`the declaration of symbol ${this.symbol.name} isn't a parameter`, {});
+        }
+        this.param = parameterDeclaration;
+    }
+    get name() {
+        return this.symbol.getName();
+    }
+    get description() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    /**
+     * Return the type of the argument in a Dagger TypeDef format.
+     */
+    get type() {
+        if (!this.symbol.valueDeclaration) {
+            throw new UnknownDaggerError("could not find symbol value declaration", {});
+        }
+        const type = this.checker.getTypeOfSymbolAtLocation(this.symbol, this.symbol.valueDeclaration);
+        const typeName = serializeType(this.checker, type);
+        return typeNameToTypedef(typeName);
+    }
+    get defaultValue() {
+        if (this.param.initializer === undefined) {
+            return undefined;
+        }
+        return this.formatDefaultValue(this.param.initializer.getText());
+    }
+    /**
+     * Return true if the parameter is optional.
+     *
+     * A parameter is considered optional if he fits one of the following:
+     * - It has a question token (e.g. `foo?: <type>`).
+     * - It's variadic (e.g. `...foo: <type>[]`).
+     * - It's nullable (e.g. `foo: <type> | null`).
+     */
+    get isOptional() {
+        return (this.param.questionToken !== undefined ||
+            this.isVariadic ||
+            this.isNullable);
+    }
+    /**
+     * Return true if the parameter is nullable.
+     *
+     * A parameter is considered nullable if itstype is a union type with `null`
+     * on the list of types.
+     * Example: `foo: string | null`.
+     */
+    get isNullable() {
+        if (!this.param.type) {
+            return false;
+        }
+        if (ts.isUnionTypeNode(this.param.type)) {
+            for (const _type of this.param.type.types) {
+                if (_type.getText() === "null") {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    get isVariadic() {
+        return this.param.dotDotDotToken !== undefined;
+    }
+    // TODO(TomChv): replace with `ToJson` method
+    // after the refactor is complete.
+    get typeDef() {
+        return {
+            name: this.name,
+            description: this.description,
+            optional: this.isOptional,
+            defaultValue: this.defaultValue,
+            isVariadic: this.isVariadic,
+            typeDef: this.type,
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            type: this.type,
+            isVariadic: this.isVariadic,
+            isNullable: this.isNullable,
+            isOptional: this.isOptional,
+            defaultValue: this.defaultValue,
+        };
+    }
+    /**
+     * The TypeScript Compiler API returns the raw default value as it is written
+     * by the user.
+     * However, some notations are not supported by GraphQL so this function
+     * formats the default value to be compatible with the GraphQL syntax.
+     *
+     * Formatting rules:
+     * - Single quote strings are converted to double quote strings.
+     *
+     * @param value The value to format.
+     */
+    formatDefaultValue(value) {
+        const isSingleQuoteString = () => value.startsWith("'") && value.endsWith("'");
+        if (isSingleQuoteString()) {
+            return `"${value.slice(1, value.length - 1)}"`;
+        }
+        return value;
+    }
+}

package/dist/introspector/scanner/abtractions/constructor.d.ts

@@ -0,0 +1,16 @@
+import ts from "typescript";
+import { Arguments } from "./argument.js";
+import { ConstructorTypeDef } from "../typeDefs.js";
+export declare class Constructor {
+    private checker;
+    private declaration;
+    constructor(checker: ts.TypeChecker, declaration: ts.ConstructorDeclaration);
+    get name(): string;
+    get arguments(): Arguments;
+    get typeDef(): ConstructorTypeDef;
+    toJSON(): {
+        args: Arguments;
+    };
+    getArgOrder(): string[];
+}
+//# sourceMappingURL=constructor.d.ts.map

package/dist/introspector/scanner/abtractions/constructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructor.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/constructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAY,SAAS,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,kBAAkB,EAAsB,MAAM,gBAAgB,CAAA;AAEvE,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,WAAW,CAA2B;gBAElC,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,EAAE,CAAC,sBAAsB;IAK3E,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,SAAS,IAAI,SAAS,CAgBzB;IAID,IAAI,OAAO,IAAI,kBAAkB,CAWhC;IAED,MAAM;;;IAMN,WAAW,IAAI,MAAM,EAAE;CAGxB"}

package/dist/introspector/scanner/abtractions/constructor.js

@@ -0,0 +1,42 @@
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { Argument } from "./argument.js";
+export class Constructor {
+    checker;
+    declaration;
+    constructor(checker, declaration) {
+        this.checker = checker;
+        this.declaration = declaration;
+    }
+    get name() {
+        return "";
+    }
+    get arguments() {
+        return this.declaration.parameters.reduce((acc, param) => {
+            const symbol = this.checker.getSymbolAtLocation(param.name);
+            if (!symbol) {
+                throw new UnknownDaggerError(`could not get constructor param: ${param.name.getText()}`, {});
+            }
+            const argument = new Argument(this.checker, symbol);
+            acc[argument.name] = argument;
+            return acc;
+        }, {});
+    }
+    // TODO(TomChv): replace with `ToJson` method
+    // after the refactor is complete.
+    get typeDef() {
+        return {
+            args: Object.entries(this.arguments).reduce((acc, [name, arg]) => {
+                acc[name] = arg.typeDef;
+                return acc;
+            }, {}),
+        };
+    }
+    toJSON() {
+        return {
+            args: this.arguments,
+        };
+    }
+    getArgOrder() {
+        return Object.keys(this.arguments);
+    }
+}

package/dist/introspector/scanner/abtractions/method.d.ts

@@ -0,0 +1,51 @@
+import ts from "typescript";
+import { Arguments } from "./argument.js";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { FunctionTypedef, TypeDef } from "../typeDefs.js";
+export type Methods = {
+    [name: string]: Method;
+};
+/**
+ * Method is an abstraction of a function or method.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export declare class Method {
+    private checker;
+    private method;
+    private symbol;
+    private signature;
+    private decorator;
+    /**
+     * Create a new Method instance.
+     *
+     * @param checker Checker to use to introspect the method.
+     * @param method The method to introspect.
+     *
+     * @throws UnknownDaggerError If the method doesn't have any symbol.
+     * @throws UnknownDaggerError If the method doesn't have any signature.
+     */
+    constructor(checker: ts.TypeChecker, method: ts.MethodDeclaration);
+    get name(): string;
+    get description(): string;
+    /**
+     * Return the alias of the method if it has one.
+     */
+    get alias(): string | undefined;
+    get arguments(): Arguments;
+    /**
+     * Return the type of the return value in a Dagger TypeDef format.
+     */
+    get returnType(): TypeDef<TypeDefKind>;
+    get typeDef(): FunctionTypedef;
+    toJSON(): {
+        name: string;
+        description: string;
+        alias: string | undefined;
+        arguments: Arguments;
+        returnType: TypeDef<TypeDefKind>;
+    };
+    getArgOrder(): string[];
+}
+//# sourceMappingURL=method.d.ts.map

package/dist/introspector/scanner/abtractions/method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/method.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAY,SAAS,EAAE,MAAM,eAAe,CAAA;AAGnD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAsB,eAAe,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAI7E,MAAM,MAAM,OAAO,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAA;AAEhD;;;;;GAKG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,MAAM,CAAsB;IAEpC,OAAO,CAAC,MAAM,CAAW;IAEzB,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,SAAS,CAA0B;IAE3C;;;;;;;;OAQG;gBACS,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC,iBAAiB;IAiCjE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAa9B;IAED,IAAI,SAAS,IAAI,SAAS,CAQzB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,OAAO,CAAC,WAAW,CAAC,CAIrC;IAED,IAAI,OAAO,IAAI,eAAe,CAe7B;IAED,MAAM;;;;;;;IAUN,WAAW,IAAI,MAAM,EAAE;CAGxB"}

package/dist/introspector/scanner/abtractions/method.js

@@ -0,0 +1,105 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { Argument } from "./argument.js";
+import { serializeType } from "../serialize.js";
+import { typeNameToTypedef } from "../utils.js";
+const METHOD_DECORATOR = "func";
+/**
+ * Method is an abstraction of a function or method.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export class Method {
+    checker;
+    method;
+    symbol;
+    signature;
+    decorator;
+    /**
+     * Create a new Method instance.
+     *
+     * @param checker Checker to use to introspect the method.
+     * @param method The method to introspect.
+     *
+     * @throws UnknownDaggerError If the method doesn't have any symbol.
+     * @throws UnknownDaggerError If the method doesn't have any signature.
+     */
+    constructor(checker, method) {
+        this.checker = checker;
+        this.method = method;
+        const methodSymbol = checker.getSymbolAtLocation(method.name);
+        if (!methodSymbol) {
+            throw new UnknownDaggerError(`could not get method symbol: ${method.name.getText()}`, {});
+        }
+        this.symbol = methodSymbol;
+        const signature = checker.getSignatureFromDeclaration(method);
+        if (!signature) {
+            throw new UnknownDaggerError(`could not get method signature: ${method.name.getText()}`, {});
+        }
+        this.signature = signature;
+        this.decorator = ts.getDecorators(method)?.find((d) => {
+            if (ts.isCallExpression(d.expression)) {
+                return d.expression.expression.getText() === METHOD_DECORATOR;
+            }
+            return false;
+        });
+    }
+    get name() {
+        return this.symbol.getName();
+    }
+    get description() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    /**
+     * Return the alias of the method if it has one.
+     */
+    get alias() {
+        if (!this.decorator) {
+            return undefined;
+        }
+        const expression = this.decorator.expression;
+        const aliasArg = expression.arguments[0];
+        if (!aliasArg) {
+            return undefined;
+        }
+        return JSON.parse(aliasArg.getText().replace(/'/g, '"'));
+    }
+    get arguments() {
+        return this.signature.parameters.reduce((acc, param) => {
+            const argument = new Argument(this.checker, param);
+            acc[argument.name] = argument;
+            return acc;
+        }, {});
+    }
+    /**
+     * Return the type of the return value in a Dagger TypeDef format.
+     */
+    get returnType() {
+        return typeNameToTypedef(serializeType(this.checker, this.signature.getReturnType()));
+    }
+    get typeDef() {
+        return {
+            name: this.name,
+            description: this.description,
+            alias: this.alias,
+            args: Object.entries(this.arguments).reduce((acc, [name, arg]) => {
+                acc[name] = arg.typeDef;
+                return acc;
+            }, {}),
+            returnType: this.returnType,
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            alias: this.alias,
+            arguments: this.arguments,
+            returnType: this.returnType,
+        };
+    }
+    getArgOrder() {
+        return Object.keys(this.arguments);
+    }
+}

package/dist/introspector/scanner/abtractions/module.d.ts

@@ -0,0 +1,18 @@
+import ts from "typescript";
+import { DaggerObject, DaggerObjects } from "./object.js";
+export declare class DaggerModule {
+    private checker;
+    private readonly files;
+    name: string;
+    constructor(checker: ts.TypeChecker, name: string | undefined, files: readonly ts.SourceFile[]);
+    get objects(): DaggerObjects;
+    get description(): string | undefined;
+    toJSON(): {
+        name: string;
+        description: string | undefined;
+        objects: {
+            [name: string]: DaggerObject;
+        };
+    };
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/introspector/scanner/abtractions/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGzD,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IAEhC,IAAI,EAAE,MAAM,CAAA;gBAGjB,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,oBAAK,EACT,KAAK,EAAE,SAAS,EAAE,CAAC,UAAU,EAAE;IAOjC,IAAI,OAAO,IAAI,aAAa,CAc3B;IAED,IAAI,WAAW,IAAI,MAAM,GAAG,SAAS,CAgCpC;IAED,MAAM;;;;;;;CAcP"}

package/dist/introspector/scanner/abtractions/module.js

@@ -0,0 +1,59 @@
+import ts from "typescript";
+import { DaggerObject } from "./object.js";
+import { isObject, toPascalCase } from "../utils.js";
+export class DaggerModule {
+    checker;
+    files;
+    name;
+    constructor(checker, name = "", files) {
+        this.checker = checker;
+        this.files = files.filter((file) => !file.isDeclarationFile);
+        this.name = toPascalCase(name);
+    }
+    get objects() {
+        const objects = {};
+        for (const file of this.files) {
+            ts.forEachChild(file, (node) => {
+                if (ts.isClassDeclaration(node) && isObject(node)) {
+                    const object = new DaggerObject(this.checker, file, node);
+                    objects[object.name] = object;
+                }
+            });
+        }
+        return objects;
+    }
+    get description() {
+        const mainObject = Object.values(this.objects).find((object) => object.name === this.name);
+        if (!mainObject) {
+            return undefined;
+        }
+        const file = mainObject.file;
+        const topLevelStatement = file.statements[0];
+        if (!topLevelStatement) {
+            return undefined;
+        }
+        // Get the range of the top level comment
+        const topLevelCommentRanges = ts.getLeadingCommentRanges(file.getFullText(), topLevelStatement.pos);
+        if (!topLevelCommentRanges || topLevelCommentRanges.length === 0) {
+            return undefined;
+        }
+        const topLevelCommentRange = topLevelCommentRanges[0];
+        return file
+            .getFullText()
+            .substring(topLevelCommentRange.pos, topLevelCommentRange.end)
+            .split("\n")
+            .slice(1, -1) // Remove start and ending comments characters `/** */`
+            .map((line) => line.replace("*", "").trim()) // Remove leading * and spaces
+            .join("\n");
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            objects: Object.entries(this.objects).reduce((acc, [name, object]) => {
+                acc[name] = object;
+                return acc;
+            }, {}),
+        };
+    }
+}

package/dist/introspector/scanner/abtractions/object.d.ts

@@ -0,0 +1,37 @@
+import ts from "typescript";
+import { Constructor } from "./constructor.js";
+import { Methods } from "./method.js";
+import { Properties } from "./property.js";
+import { ClassTypeDef } from "../typeDefs.js";
+export type DaggerObjects = {
+    [name: string]: DaggerObject;
+};
+export declare class DaggerObject {
+    private checker;
+    private class;
+    private symbol;
+    file: ts.SourceFile;
+    /**
+     *
+     * @param checker The checker to use to introspect the class.
+     * @param classDeclaration The class to introspect.
+     *
+     * @throws UnknownDaggerError If the class doesn't have a name.
+     * @throws UnknownDaggerError If the class doesn't have a symbol.
+     */
+    constructor(checker: ts.TypeChecker, file: ts.SourceFile, classDeclaration: ts.ClassDeclaration);
+    get name(): string;
+    get description(): string;
+    get _constructor(): Constructor | undefined;
+    get methods(): Methods;
+    get properties(): Properties;
+    get typeDef(): ClassTypeDef;
+    toJSON(): {
+        name: string;
+        description: string;
+        constructor: Constructor | undefined;
+        methods: Methods;
+        properties: Properties;
+    };
+}
+//# sourceMappingURL=object.d.ts.map

package/dist/introspector/scanner/abtractions/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9C,OAAO,EAAU,OAAO,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAY,MAAM,eAAe,CAAA;AACpD,OAAO,EAAE,YAAY,EAAiC,MAAM,gBAAgB,CAAA;AAG5E,MAAM,MAAM,aAAa,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAA;AAE5D,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,KAAK,CAAqB;IAElC,OAAO,CAAC,MAAM,CAAW;IAElB,IAAI,EAAE,EAAE,CAAC,UAAU,CAAA;IAE1B;;;;;;;OAOG;gBAED,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,gBAAgB,EAAE,EAAE,CAAC,gBAAgB;IAwBvC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED,IAAI,YAAY,IAAI,WAAW,GAAG,SAAS,CAe1C;IAED,IAAI,OAAO,IAAI,OAAO,CAUrB;IAED,IAAI,UAAU,IAAI,UAAU,CAY3B;IAID,IAAI,OAAO,IAAI,YAAY,CAoB1B;IAED,MAAM;;;;;;;CASP"}