@dagger.io/dagger 0.13.2 → 0.13.4

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

@@ -0,0 +1,73 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { enumType } from "../../decorators/decorators.js";
+import { DaggerEnumValue } from "./enumValue.js";
+export const ENUM_DECORATOR = enumType.name;
+/**
+ * Return true if the given class declaration has the decorator @enum() on
+ * top of its declaration.
+ */
+export function isEnumDecorated(object) {
+    return (ts.getDecorators(object)?.find((d) => {
+        if (ts.isCallExpression(d.expression)) {
+            return d.expression.expression.getText() === ENUM_DECORATOR;
+        }
+        return false;
+    }) !== undefined);
+}
+export class DaggerEnum {
+    checker;
+    enumClass;
+    symbol;
+    file;
+    _name;
+    _description;
+    _values;
+    constructor(checker, file, enumClassDeclaration) {
+        this.checker = checker;
+        this.enumClass = enumClassDeclaration;
+        this.file = file;
+        if (!enumClassDeclaration.name) {
+            throw new UnknownDaggerError(`could not introspect enum class: ${enumClassDeclaration}`, {});
+        }
+        const enumClassSymbol = checker.getSymbolAtLocation(enumClassDeclaration.name);
+        if (!enumClassSymbol) {
+            throw new UnknownDaggerError(`could not get enum class symbol: ${enumClassDeclaration.name.getText()}`, {});
+        }
+        this.symbol = enumClassSymbol;
+        // Preload definition to optimize the introspection.
+        this._name = this.loadName();
+        this._description = this.loadDescription();
+        this._values = this.loadEnumValues();
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    get values() {
+        return this._values;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            values: this._values,
+        };
+    }
+    loadName() {
+        return this.symbol.getName();
+    }
+    loadDescription() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    loadEnumValues() {
+        return this.enumClass.members
+            .filter((member) => ts.isPropertyDeclaration(member))
+            .reduce((acc, member) => {
+            const value = new DaggerEnumValue(this.checker, member);
+            return { ...acc, [value.name]: value };
+        }, {});
+    }
+}

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

@@ -0,0 +1,24 @@
+import ts from "typescript";
+export type DaggerEnumValues = {
+    [name: string]: DaggerEnumValue;
+};
+export declare class DaggerEnumValue {
+    private checker;
+    private property;
+    private symbol;
+    private _name;
+    private _value;
+    private _description;
+    constructor(checker: ts.TypeChecker, property: ts.PropertyDeclaration);
+    get name(): string;
+    get value(): string;
+    get description(): string;
+    toJSON(): {
+        name: string;
+        description: string;
+    };
+    private loadName;
+    private loadValue;
+    private loadDescription;
+}
+//# sourceMappingURL=enumValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enumValue.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/enumValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAI3B,MAAM,MAAM,gBAAgB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;CAAE,CAAA;AAElE,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,QAAQ,CAAwB;IAExC,OAAO,CAAC,MAAM,CAAW;IAEzB,OAAO,CAAC,KAAK,CAAQ;IAErB,OAAO,CAAC,MAAM,CAAQ;IAEtB,OAAO,CAAC,YAAY,CAAQ;gBAEhB,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE,CAAC,mBAAmB;IAkBrE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,MAAM;;;;IAON,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,eAAe;CAKxB"}

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

@@ -0,0 +1,51 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+export class DaggerEnumValue {
+    checker;
+    property;
+    symbol;
+    _name;
+    _value;
+    _description;
+    constructor(checker, property) {
+        this.checker = checker;
+        this.property = property;
+        const propertySymbol = checker.getSymbolAtLocation(property.name);
+        if (!propertySymbol) {
+            throw new UnknownDaggerError(`could not get property symbol: ${property.name.getText()}`, {});
+        }
+        this.symbol = propertySymbol;
+        this._name = this.loadName();
+        this._value = this.loadValue();
+        this._description = this.loadDescription();
+    }
+    get name() {
+        return this._name;
+    }
+    get value() {
+        return this._value;
+    }
+    get description() {
+        return this._description;
+    }
+    toJSON() {
+        return {
+            name: this.value,
+            description: this.description,
+        };
+    }
+    loadName() {
+        return this.symbol.getName();
+    }
+    // Load the value of the enum value from the property initializer.
+    // If the initializer is not set, it will throw an error.
+    loadValue() {
+        if (!this.property.initializer) {
+            throw new Error("Dagger enum value has no value set");
+        }
+        return JSON.parse(this.property.initializer.getText());
+    }
+    loadDescription() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+}

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

@@ -0,0 +1,67 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typeDefs.js";
+import { Arguments } from "./argument.js";
+export declare const METHOD_DECORATOR: string;
+/**
+ * Return true if the given method has the decorator @fct() on top
+ * of its declaration.
+ *
+ * @param method The method to check
+ */
+export declare function isMethodDecorated(method: ts.MethodDeclaration): boolean;
+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 symbol;
+    private signature;
+    private decorator;
+    private _name;
+    private _description;
+    private _alias;
+    private _arguments;
+    private _returnType;
+    /**
+     * 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>;
+    toJSON(): {
+        name: string;
+        description: string;
+        alias: string | undefined;
+        arguments: Arguments;
+        returnType: TypeDef<TypeDefKind>;
+    };
+    getArgOrder(): string[];
+    private loadName;
+    private loadDescription;
+    private loadAlias;
+    private loadArguments;
+    private loadReturnType;
+}
+//# 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;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAGxD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACxC,OAAO,EAAY,SAAS,EAAE,MAAM,eAAe,CAAA;AAGnD,eAAO,MAAM,gBAAgB,QAAY,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,EAAE,CAAC,iBAAiB,GAAG,OAAO,CAUvE;AAED,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,CAAW;IAEzB,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,SAAS,CAA0B;IAG3C,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,UAAU,CAAW;IAC7B,OAAO,CAAC,WAAW,CAAsB;IAEzC;;;;;;;;OAQG;gBACS,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC,iBAAiB;IAuCjE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,OAAO,CAAC,WAAW,CAAC,CAErC;IAED,MAAM;;;;;;;IAUN,WAAW,IAAI,MAAM,EAAE;IAIvB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,cAAc;CAGvB"}

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

@@ -0,0 +1,132 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { func } from "../../decorators/decorators.js";
+import { Argument } from "./argument.js";
+import { typeToTypedef } from "./typeToTypedef.js";
+export const METHOD_DECORATOR = func.name;
+/**
+ * Return true if the given method has the decorator @fct() on top
+ * of its declaration.
+ *
+ * @param method The method to check
+ */
+export function isMethodDecorated(method) {
+    return (ts.getDecorators(method)?.find((d) => {
+        if (ts.isCallExpression(d.expression)) {
+            return d.expression.expression.getText() === METHOD_DECORATOR;
+        }
+        return false;
+    }) !== undefined);
+}
+/**
+ * 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;
+    symbol;
+    signature;
+    decorator;
+    // Preloaded values.
+    _name;
+    _description;
+    _alias;
+    _arguments;
+    _returnType;
+    /**
+     * 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;
+        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;
+        });
+        // Preload to optimize the introspection.
+        this._name = this.loadName();
+        this._description = this.loadDescription();
+        this._alias = this.loadAlias();
+        this._arguments = this.loadArguments();
+        this._returnType = this.loadReturnType();
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    /**
+     * Return the alias of the method if it has one.
+     */
+    get alias() {
+        return this._alias;
+    }
+    get arguments() {
+        return this._arguments;
+    }
+    /**
+     * Return the type of the return value in a Dagger TypeDef format.
+     */
+    get returnType() {
+        return 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);
+    }
+    loadName() {
+        return this.symbol.getName();
+    }
+    loadDescription() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    loadAlias() {
+        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, '"'));
+    }
+    loadArguments() {
+        return this.signature.parameters.reduce((acc, param) => {
+            const argument = new Argument(this.checker, param);
+            acc[argument.name] = argument;
+            return acc;
+        }, {});
+    }
+    loadReturnType() {
+        return typeToTypedef(this.checker, this.signature.getReturnType());
+    }
+}

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

@@ -0,0 +1,26 @@
+import ts from "typescript";
+import { DaggerEnums } from "./enum.js";
+import { DaggerObjects } from "./object.js";
+export declare class DaggerModule {
+    private checker;
+    private readonly files;
+    name: string;
+    private _description;
+    private _objects;
+    private _enums;
+    constructor(checker: ts.TypeChecker, name: string | undefined, files: readonly ts.SourceFile[]);
+    get objects(): DaggerObjects;
+    get enums(): DaggerEnums;
+    get description(): string | undefined;
+    toJSON(): {
+        name: string;
+        description: string | undefined;
+        objects: DaggerObjects;
+        enums: DaggerEnums;
+    };
+    private loadObjects;
+    private loadEnums;
+    private loadDescription;
+    private toPascalCase;
+}
+//# 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,EAAc,WAAW,EAAmB,MAAM,WAAW,CAAA;AACpE,OAAO,EAAgB,aAAa,EAAqB,MAAM,aAAa,CAAA;AAE5E,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IAEhC,IAAI,EAAE,MAAM,CAAA;IAGnB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,MAAM,CAAa;gBAGzB,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,oBAAK,EACT,KAAK,EAAE,SAAS,EAAE,CAAC,UAAU,EAAE;IAYjC,IAAI,OAAO,IAAI,aAAa,CAE3B;IAED,IAAI,KAAK,IAAI,WAAW,CAEvB;IAED,IAAI,WAAW,IAAI,MAAM,GAAG,SAAS,CAEpC;IAED,MAAM;;;;;;IASN,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,SAAS;IAgBjB,OAAO,CAAC,eAAe;IAkCvB,OAAO,CAAC,YAAY;CAqBrB"}

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

@@ -0,0 +1,103 @@
+import ts from "typescript";
+import { DaggerEnum, isEnumDecorated } from "./enum.js";
+import { DaggerObject, isObjectDecorated } from "./object.js";
+export class DaggerModule {
+    checker;
+    files;
+    name;
+    // Preloaded values.
+    _description;
+    _objects;
+    _enums;
+    constructor(checker, name = "", files) {
+        this.checker = checker;
+        this.files = files.filter((file) => !file.isDeclarationFile);
+        this.name = this.toPascalCase(name);
+        // Preload values to optimize introspection.
+        this._objects = this.loadObjects();
+        this._enums = this.loadEnums();
+        this._description = this.loadDescription();
+    }
+    get objects() {
+        return this._objects;
+    }
+    get enums() {
+        return this._enums;
+    }
+    get description() {
+        return this._description;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            objects: this._objects,
+            enums: this._enums,
+        };
+    }
+    loadObjects() {
+        const objects = {};
+        for (const file of this.files) {
+            ts.forEachChild(file, (node) => {
+                if (ts.isClassDeclaration(node) && isObjectDecorated(node)) {
+                    const object = new DaggerObject(this.checker, file, node);
+                    objects[object.name] = object;
+                }
+            });
+        }
+        return objects;
+    }
+    loadEnums() {
+        const daggerEnums = {};
+        for (const file of this.files) {
+            ts.forEachChild(file, (node) => {
+                if (ts.isClassDeclaration(node) && isEnumDecorated(node)) {
+                    const daggerEnum = new DaggerEnum(this.checker, file, node);
+                    daggerEnums[daggerEnum.name] = daggerEnum;
+                }
+            });
+        }
+        return daggerEnums;
+    }
+    loadDescription() {
+        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");
+    }
+    toPascalCase(input) {
+        const words = input
+            .replace(/[^a-zA-Z0-9]/g, " ") // Replace non-alphanumeric characters with spaces
+            .split(/\s+/)
+            .filter((word) => word.length > 0);
+        if (words.length === 0) {
+            return ""; // No valid words found
+        }
+        // It's an edge case when moduleName is already in PascalCase or camelCase
+        if (words.length === 1) {
+            return words[0].charAt(0).toUpperCase() + words[0].slice(1);
+        }
+        const pascalCase = words
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join("");
+        return pascalCase;
+    }
+}

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

@@ -0,0 +1,52 @@
+import ts from "typescript";
+import { Constructor } from "./constructor.js";
+import { Methods } from "./method.js";
+import { Properties } from "./property.js";
+export declare const OBJECT_DECORATOR: string;
+/**
+ * Return true if the given class declaration has the decorator @obj() on
+ * top of its declaration.
+ * @param object
+ */
+export declare function isObjectDecorated(object: ts.ClassDeclaration): boolean;
+export type DaggerObjects = {
+    [name: string]: DaggerObject;
+};
+export declare class DaggerObject {
+    private checker;
+    private class;
+    private symbol;
+    file: ts.SourceFile;
+    private _name;
+    private _description;
+    private _classConstructor;
+    private _methods;
+    private _properties;
+    /**
+     *
+     * @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;
+    toJSON(): {
+        name: string;
+        description: string;
+        constructor: Constructor | undefined;
+        methods: Methods;
+        properties: Properties;
+    };
+    private loadName;
+    private loadDescription;
+    private loadConstructor;
+    private loadMethods;
+    private loadProperties;
+}
+//# 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;AAI3B,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAU,OAAO,EAAqB,MAAM,aAAa,CAAA;AAChE,OAAO,EAAE,UAAU,EAAY,MAAM,eAAe,CAAA;AAEpD,eAAO,MAAM,gBAAgB,QAAc,CAAA;AAE3C;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,EAAE,CAAC,gBAAgB,GAAG,OAAO,CAUtE;AAED,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;IAG1B,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAAY;IAE/B;;;;;;;OAOG;gBAED,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,gBAAgB,EAAE,EAAE,CAAC,gBAAgB;IA+BvC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,YAAY,IAAI,WAAW,GAAG,SAAS,CAE1C;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,UAAU,IAAI,UAAU,CAE3B;IAED,MAAM;;;;;;;IAUN,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,WAAW;IAcnB,OAAO,CAAC,cAAc;CAavB"}

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

@@ -0,0 +1,118 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { object } from "../../decorators/decorators.js";
+import { Constructor } from "./constructor.js";
+import { Method, isMethodDecorated } from "./method.js";
+import { Property } from "./property.js";
+export const OBJECT_DECORATOR = object.name;
+/**
+ * Return true if the given class declaration has the decorator @obj() on
+ * top of its declaration.
+ * @param object
+ */
+export function isObjectDecorated(object) {
+    return (ts.getDecorators(object)?.find((d) => {
+        if (ts.isCallExpression(d.expression)) {
+            return d.expression.expression.getText() === OBJECT_DECORATOR;
+        }
+        return false;
+    }) !== undefined);
+}
+export class DaggerObject {
+    checker;
+    class;
+    symbol;
+    file;
+    // Preloaded values.
+    _name;
+    _description;
+    _classConstructor;
+    _methods;
+    _properties;
+    /**
+     *
+     * @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, file, classDeclaration) {
+        this.checker = checker;
+        this.class = classDeclaration;
+        this.file = file;
+        if (!classDeclaration.name) {
+            throw new UnknownDaggerError(`could not introspect class: ${classDeclaration}`, {});
+        }
+        const classSymbol = checker.getSymbolAtLocation(classDeclaration.name);
+        if (!classSymbol) {
+            throw new UnknownDaggerError(`could not get class symbol: ${classDeclaration.name.getText()}`, {});
+        }
+        this.symbol = classSymbol;
+        // Preload values to optimize introspection.
+        this._name = this.loadName();
+        this._description = this.loadDescription();
+        this._classConstructor = this.loadConstructor();
+        this._methods = this.loadMethods();
+        this._properties = this.loadProperties();
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    get _constructor() {
+        return this._classConstructor;
+    }
+    get methods() {
+        return this._methods;
+    }
+    get properties() {
+        return this._properties;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            constructor: this._constructor,
+            methods: this.methods,
+            properties: this.properties,
+        };
+    }
+    loadName() {
+        return this.symbol.getName();
+    }
+    loadDescription() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    loadConstructor() {
+        const constructor = this.class.members.find((member) => {
+            if (ts.isConstructorDeclaration(member)) {
+                return true;
+            }
+        });
+        if (!constructor) {
+            return undefined;
+        }
+        return new Constructor(this.checker, constructor);
+    }
+    loadMethods() {
+        return this.class.members
+            .filter((member) => ts.isMethodDeclaration(member) && isMethodDecorated(member))
+            .reduce((acc, member) => {
+            const method = new Method(this.checker, member);
+            acc[method.alias ?? method.name] = method;
+            return acc;
+        }, {});
+    }
+    loadProperties() {
+        return this.class.members
+            .filter((member) => ts.isPropertyDeclaration(member))
+            .reduce((acc, member) => {
+            const property = new Property(this.checker, member);
+            acc[property.alias ?? property.name] = property;
+            return acc;
+        }, {});
+    }
+}