@dagger.io/dagger 0.13.1 → 0.13.2

package/dist/introspector/decorators/decorators.js

@@ -1,47 +0,0 @@
-/**
- * Expose the decorator publicly, so they insert data into the global registry.
- */
-import { registry } from "../registry/registry.js";
-/**
- * The definition of the `@object` decorator that should be on top of any
- * class module that must be exposed to the Dagger API.
- *
- */
-export const object = registry.object;
-/**
- * The definition of @func decorator that should be on top of any
- * class' method that must be exposed to the Dagger API.
- *
- * @param alias The alias to use for the field when exposed on the API.
- */
-export const func = registry.func;
-/**
- * The definition of @field decorator that should be on top of any
- * class' property that must be exposed to the Dagger API.
- *
- * @deprecated In favor of `@func`
- * @param alias The alias to use for the field when exposed on the API.
- */
-export const field = registry.field;
-/**
- * The definition of the `@enumType` decorator that should be on top of any
- * class module that must be exposed to the Dagger API as enumeration.
- */
-export const enumType = registry.enumType;
-/**
- * Add a `@argument` decorator to an argument of type `Directory` or `File` to load
- * its contents from the module context directory.
- *
- * The context directory is the git repository containing the module.
- * If there's no git repository, the context directory is the directory containing
- * the module source code.
- *
- * @param opts.defaultPath Only applies to arguments of type File or Directory. If the argument is not set,
- * load it from the given path in the context directory.
- * @param opts.ignore Only applies to arguments of type Directory. The ignore patterns are applied to the input directory,
- * and matching entries are filtered out, in a cache-efficient manner..
- *
- * Relative paths are relative to the current source files.
- * Absolute paths are rooted to the module context directory.
- */
-export const argument = registry.argument;

package/dist/introspector/registry/registry.d.ts

@@ -1,89 +0,0 @@
-import "reflect-metadata";
-export type Class = {
-    new (...args: any[]): any;
-};
-export type State = {
-    [property: string]: any;
-};
-export type Args = Record<string, unknown>;
-export type ArgumentOptions = {
-    /**
-     * The contextual value to use for the argument.
-     *
-     * This should only be used for Directory or File types.
-     *
-     * An abslute path would be related to the context source directory (the git repo root or the module source root).
-     * A relative path would be relative to the module source root.
-     */
-    defaultPath?: string;
-    /**
-     * Patterns to ignore when loading the contextual argument value.
-     *
-     * This should only be used for Directory types.
-     */
-    ignore?: string[];
-};
-/**
- * Registry stores class and method that have the @object decorator.
- *
- * This is a convenient way to make possible the invocation of class' function.
- *
- * The decorator @object store the class into the Registry, but also all the
- * users method's name.
- * It doesn't consider the `@func` decorator because this is
- * used by the Dagger API to know what to expose or not.
- * This might lead to unnecessary data register into the registry, but
- * we use map as datastructure to optimize the searching process
- * since we directly look through a key into the `class_` member of
- * RegistryClass.
- */
-export declare class Registry {
-    /**
-     * The definition of the @object decorator that should be on top of any
-     * class module that must be exposed to the Dagger API.
-     */
-    object: () => (<T extends Class>(constructor: T) => T);
-    /**
-     * The definition of the @enum decorator that should be on top of any
-     * class module that must be exposed to the Dagger API as enumeration.
-     */
-    enumType: () => (<T extends Class>(constructor: T) => T);
-    /**
-     * The definition of @field decorator that should be on top of any
-     * class' property that must be exposed to the Dagger API.
-     *
-     * @deprecated In favor of `@func`
-     * @param alias The alias to use for the field when exposed on the API.
-     */
-    field: (alias?: string) => ((target: object, propertyKey: string) => void);
-    /**
-     * The definition of @func decorator that should be on top of any
-     * class' method that must be exposed to the Dagger API.
-     */
-    func: (alias?: string) => ((target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor) => void);
-    argument: (opts?: ArgumentOptions) => ((target: object, propertyKey: string, parameterIndex: number) => void);
-    /**
-     * Build a class that is part of the module itself so you can
-     * access its sub functions.
-     *
-     * If there's no class associated, return the object itself.
-     */
-    buildClass(object: string, state: State): any;
-    /**
-     * getResult check for the object and method in the registry and call it
-     * with the given input and state.
-     *
-     * This is the function responsible for any module methods execution.
-     *
-     * @param object The class to look for
-     * @param method The method to call in the class
-     * @param state The current state of the class
-     * @param inputs The input to send to the method to call
-     */
-    getResult(object: string, method: string, state: State, inputs: Args): Promise<any>;
-}
-/**
- * The default registry used in any module.
- */
-export declare const registry: Registry;
-//# sourceMappingURL=registry.d.ts.map

package/dist/introspector/registry/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../introspector/registry/registry.ts"],"names":[],"mappings":"AAKA,OAAO,kBAAkB,CAAA;AAIzB,MAAM,MAAM,KAAK,GAAG;IAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAA;CAAE,CAAA;AAEjD,MAAM,MAAM,KAAK,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAA;AAE/C,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAU1C,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB;;;OAGG;IACH,MAAM,QAAO,CAAC,CAAC,CAAe,SAAL,KAAK,EAAE,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,CAMpD;IAED;;;OAGG;IACH,QAAQ,QAAO,CAAC,CAAC,CAAe,SAAL,KAAK,EAAE,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,CAItD;IAED;;;;;;OAMG;IACH,KAAK,WAAY,MAAM,KAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC,CAIxE;IAED;;;OAGG;IACH,IAAI,WACM,MAAM,KACb,CAAC,CACF,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,UAAU,CAAC,EAAE,kBAAkB,KAC5B,IAAI,CAAC,CAMT;IAED,QAAQ,UACC,eAAe,KACrB,CAAC,CACF,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,KACnB,IAAI,CAAC,CAET;IAED;;;;;OAKG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,GAAG;IAY7C;;;;;;;;;;OAUG;IACG,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,IAAI,GACX,OAAO,CAAC,GAAG,CAAC;CAiChB;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,UAAiB,CAAA"}

package/dist/introspector/registry/registry.js

@@ -1,115 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// @experimentalDecorators
-// @emitDecoratorMetadata
-import "reflect-metadata";
-import { UnknownDaggerError } from "../../common/errors/UnknownDaggerError.js";
-/**
- * Registry stores class and method that have the @object decorator.
- *
- * This is a convenient way to make possible the invocation of class' function.
- *
- * The decorator @object store the class into the Registry, but also all the
- * users method's name.
- * It doesn't consider the `@func` decorator because this is
- * used by the Dagger API to know what to expose or not.
- * This might lead to unnecessary data register into the registry, but
- * we use map as datastructure to optimize the searching process
- * since we directly look through a key into the `class_` member of
- * RegistryClass.
- */
-export class Registry {
-    /**
-     * The definition of the @object decorator that should be on top of any
-     * class module that must be exposed to the Dagger API.
-     */
-    object = () => {
-        return (constructor) => {
-            Reflect.defineMetadata(constructor.name, { class_: constructor }, this);
-            return constructor;
-        };
-    };
-    /**
-     * The definition of the @enum decorator that should be on top of any
-     * class module that must be exposed to the Dagger API as enumeration.
-     */
-    enumType = () => {
-        return (constructor) => {
-            return constructor;
-        };
-    };
-    /**
-     * The definition of @field decorator that should be on top of any
-     * class' property that must be exposed to the Dagger API.
-     *
-     * @deprecated In favor of `@func`
-     * @param alias The alias to use for the field when exposed on the API.
-     */
-    field = (alias) => {
-        return (target, propertyKey) => {
-            // A placeholder to declare field in the registry.
-        };
-    };
-    /**
-     * The definition of @func decorator that should be on top of any
-     * class' method that must be exposed to the Dagger API.
-     */
-    func = (alias) => {
-        return (target, propertyKey, descriptor) => { };
-    };
-    argument = (opts) => {
-        return (target, propertyKey, parameterIndex) => { };
-    };
-    /**
-     * Build a class that is part of the module itself so you can
-     * access its sub functions.
-     *
-     * If there's no class associated, return the object itself.
-     */
-    buildClass(object, state) {
-        const resolver = Reflect.getMetadata(object, this);
-        if (!resolver) {
-            return object;
-        }
-        let r = Object.create(resolver.class_.prototype);
-        r = Object.assign(r, state);
-        return r;
-    }
-    /**
-     * getResult check for the object and method in the registry and call it
-     * with the given input and state.
-     *
-     * This is the function responsible for any module methods execution.
-     *
-     * @param object The class to look for
-     * @param method The method to call in the class
-     * @param state The current state of the class
-     * @param inputs The input to send to the method to call
-     */
-    async getResult(object, method, state, inputs) {
-        // Retrieve the resolver class from its key
-        const resolver = Reflect.getMetadata(object, this);
-        if (!resolver) {
-            throw new UnknownDaggerError(`${object} is not register as a resolver`, {});
-        }
-        // If method is nil, apply the constructor.
-        if (method === "") {
-            return new resolver.class_(...Object.values(inputs));
-        }
-        // Instantiate the class without calling the constructor
-        let r = Object.create(resolver.class_.prototype);
-        // Safety check to make sure the method called exist in the class
-        // to avoid the app to crash brutally.
-        if (!r[method]) {
-            throw new UnknownDaggerError(`${method} is not registered in the resolver ${object}`, {});
-        }
-        // Apply state to the class
-        r = Object.assign(r, state);
-        // Execute and return the result
-        return await r[method](...Object.values(inputs));
-    }
-}
-/**
- * The default registry used in any module.
- */
-export const registry = new Registry();

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

@@ -1,104 +0,0 @@
-import ts from "typescript";
-import { TypeDefKind } from "../../../api/client.gen.js";
-import { TypeDef } from "../typeDefs.js";
-export declare const ARGUMENT_DECORATOR: string;
-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;
-    private _name;
-    private _description;
-    private _type;
-    private _defaultValue;
-    private _isOptional;
-    private _isNullable;
-    private _isVariadic;
-    private _defaultPath?;
-    private _ignore?;
-    /**
-     * 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 defaultPath(): string | undefined;
-    get ignore(): string[] | undefined;
-    toJSON(): {
-        name: string;
-        description: string;
-        type: TypeDef<TypeDefKind>;
-        isVariadic: boolean;
-        isNullable: boolean;
-        isOptional: boolean;
-        defaultValue: string | undefined;
-        defaultPath: string | undefined;
-        ignore: string[] | undefined;
-    };
-    private loadName;
-    private loadDescription;
-    private loadType;
-    private loadDefaultValue;
-    /**
-     * Return true if the parameter is optional.
-     *
-     * A parameter is considered optional if:
-     * - It has a question token (e.g. `foo?: <type>`).
-     * - It's variadic (e.g. `...foo: <type>[]`).
-     * - It's nullable (e.g. `foo: <type> | null`).
-     */
-    private loadIsOptional;
-    private loadIsNullable;
-    private loadIsVariadic;
-    /**
-     * 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;
-    private loadMetadata;
-}
-//# sourceMappingURL=argument.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"argument.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/argument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAIxD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAGxC,eAAO,MAAM,kBAAkB,QAAgB,CAAA;AAE/C,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;IAGtC,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAQ;IAC7B,OAAO,CAAC,OAAO,CAAC,CAAU;IAE1B;;;;;;;;OAQG;gBACS,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM;IAiCrD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,CAE/B;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,SAAS,CAErC;IAED;;;;;;;OAOG;IACH,IAAI,UAAU,IAAI,OAAO,CAExB;IAED;;;;;;OAMG;IACH,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,IAAI,WAAW,IAAI,MAAM,GAAG,SAAS,CAEpC;IAED,IAAI,MAAM,IAAI,MAAM,EAAE,GAAG,SAAS,CAEjC;IAED,MAAM;;;;;;;;;;;IAcN,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,QAAQ;IAgBhB,OAAO,CAAC,gBAAgB;IAQxB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,cAAc;IAgBtB,OAAO,CAAC,cAAc;IAItB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,YAAY;CAgCrB"}

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

@@ -1,207 +0,0 @@
-import ts from "typescript";
-import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
-import { argument } from "../../decorators/decorators.js";
-import { typeToTypedef } from "./typeToTypedef.js";
-export const ARGUMENT_DECORATOR = argument.name;
-/**
- * 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;
-    // Preloaded values.
-    _name;
-    _description;
-    _type;
-    _defaultValue;
-    _isOptional;
-    _isNullable;
-    _isVariadic;
-    _defaultPath;
-    _ignore;
-    /**
-     * 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;
-        // Preload to optimize the introspection.
-        this._name = this.loadName();
-        this._description = this.loadDescription();
-        this._type = this.loadType();
-        this._defaultValue = this.loadDefaultValue();
-        this._isNullable = this.loadIsNullable();
-        this._isVariadic = this.loadIsVariadic();
-        this._isOptional = this.loadIsOptional();
-        this.loadMetadata();
-    }
-    get name() {
-        return this._name;
-    }
-    get description() {
-        return this._description;
-    }
-    /**
-     * Return the type of the argument in a Dagger TypeDef format.
-     */
-    get type() {
-        return this._type;
-    }
-    get defaultValue() {
-        return this._defaultValue;
-    }
-    /**
-     * 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._isOptional;
-    }
-    /**
-     * 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() {
-        return this._isNullable;
-    }
-    get isVariadic() {
-        return this._isVariadic;
-    }
-    get defaultPath() {
-        return this._defaultPath;
-    }
-    get ignore() {
-        return this._ignore;
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            description: this.description,
-            type: this.type,
-            isVariadic: this.isVariadic,
-            isNullable: this.isNullable,
-            isOptional: this.isOptional,
-            defaultValue: this.defaultValue,
-            defaultPath: this.defaultPath,
-            ignore: this.ignore,
-        };
-    }
-    loadName() {
-        return this.symbol.getName();
-    }
-    loadDescription() {
-        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
-    }
-    loadType() {
-        if (!this.symbol.valueDeclaration) {
-            throw new UnknownDaggerError("could not find symbol value declaration", {});
-        }
-        const type = this.checker.getTypeOfSymbolAtLocation(this.symbol, this.symbol.valueDeclaration);
-        return typeToTypedef(this.checker, type);
-    }
-    loadDefaultValue() {
-        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:
-     * - It has a question token (e.g. `foo?: <type>`).
-     * - It's variadic (e.g. `...foo: <type>[]`).
-     * - It's nullable (e.g. `foo: <type> | null`).
-     */
-    loadIsOptional() {
-        return (this.param.questionToken !== undefined ||
-            this.isVariadic ||
-            this.isNullable);
-    }
-    loadIsNullable() {
-        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;
-    }
-    loadIsVariadic() {
-        return this.param.dotDotDotToken !== 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.
-     */
-    formatDefaultValue(value) {
-        const isSingleQuoteString = () => value.startsWith("'") && value.endsWith("'");
-        if (isSingleQuoteString()) {
-            return `"${value.slice(1, value.length - 1)}"`;
-        }
-        return value;
-    }
-    loadMetadata() {
-        const contextDecorator = ts.getDecorators(this.param)?.find((d) => {
-            if (ts.isCallExpression(d.expression)) {
-                return d.expression.expression.getText() === ARGUMENT_DECORATOR;
-            }
-            return false;
-        });
-        if (!contextDecorator) {
-            return undefined;
-        }
-        const expression = contextDecorator.expression;
-        const arg = expression.arguments[0];
-        if (!arg) {
-            return;
-        }
-        // We eval the string to convert it to a JavaScript object, because parsing it
-        // with JSON.parse will fails if the properties are not quoted.
-        const parsedArg = eval(`(${arg.getText()})`);
-        if (parsedArg.defaultPath) {
-            this._defaultPath = parsedArg.defaultPath;
-        }
-        if (parsedArg.ignore) {
-            this._ignore = parsedArg.ignore;
-        }
-        return;
-    }
-}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"constructor.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/constructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAY,SAAS,EAAE,MAAM,eAAe,CAAA;AAEnD,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,WAAW,CAA2B;IAG9C,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,UAAU,CAAW;gBAEjB,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,EAAE,CAAC,sBAAsB;IAQ3E,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,SAAS,IAAI,SAAS,CAEzB;IAED,MAAM;;;IAMN,WAAW,IAAI,MAAM,EAAE;IAIvB,OAAO,CAAC,aAAa;CAiBtB"}

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

@@ -1,40 +0,0 @@
-import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
-import { Argument } from "./argument.js";
-export class Constructor {
-    checker;
-    declaration;
-    // Preloaded values.
-    _name = "";
-    _arguments;
-    constructor(checker, declaration) {
-        this.checker = checker;
-        this.declaration = declaration;
-        // Preload values.
-        this._arguments = this.loadArguments();
-    }
-    get name() {
-        return this._name;
-    }
-    get arguments() {
-        return this._arguments;
-    }
-    toJSON() {
-        return {
-            args: this.arguments,
-        };
-    }
-    getArgOrder() {
-        return Object.keys(this.arguments);
-    }
-    loadArguments() {
-        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;
-        }, {});
-    }
-}

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

@@ -1,33 +0,0 @@
-import ts from "typescript";
-import { DaggerEnumValues } from "./enumValue.js";
-export declare const ENUM_DECORATOR: string;
-/**
- * Return true if the given class declaration has the decorator @enum() on
- * top of its declaration.
- */
-export declare function isEnumDecorated(object: ts.ClassDeclaration): boolean;
-export type DaggerEnums = {
-    [name: string]: DaggerEnum;
-};
-export declare class DaggerEnum {
-    private checker;
-    private enumClass;
-    private symbol;
-    private file;
-    private _name;
-    private _description;
-    private _values;
-    constructor(checker: ts.TypeChecker, file: ts.SourceFile, enumClassDeclaration: ts.ClassDeclaration);
-    get name(): string;
-    get description(): string;
-    get values(): DaggerEnumValues;
-    toJSON(): {
-        name: string;
-        description: string;
-        values: DaggerEnumValues;
-    };
-    private loadName;
-    private loadDescription;
-    private loadEnumValues;
-}
-//# sourceMappingURL=enum.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/enum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAI3B,OAAO,EAAmB,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAElE,eAAO,MAAM,cAAc,QAAgB,CAAA;AAE3C;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,EAAE,CAAC,gBAAgB,GAAG,OAAO,CAUpE;AAED,MAAM,MAAM,WAAW,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAA;AAExD,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,SAAS,CAAqB;IAEtC,OAAO,CAAC,MAAM,CAAW;IAEzB,OAAO,CAAC,IAAI,CAAe;IAE3B,OAAO,CAAC,KAAK,CAAQ;IAErB,OAAO,CAAC,YAAY,CAAQ;IAE5B,OAAO,CAAC,OAAO,CAAkB;gBAG/B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,oBAAoB,EAAE,EAAE,CAAC,gBAAgB;IA+B3C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,MAAM,IAAI,gBAAgB,CAE7B;IAED,MAAM;;;;;IAQN,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,cAAc;CAYvB"}