@dagger.io/dagger 0.9.3 → 0.9.5

package/dist/introspector/registry/registry.js

@@ -0,0 +1,125 @@
+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` or `field` decorators 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 {
+    classes = {};
+    /**
+     * The definition of the @object decorator that should be on top of any
+     * class module that must be exposed to the Dagger API.
+     *
+     */
+    object = (constructor) => {
+        const methods = [];
+        // Create a dummy instance of the constructor to loop through its properties
+        // We only register user's method and ignore Typescript default method
+        let proto = new constructor();
+        while (proto && proto !== Object.prototype) {
+            const ownMethods = Object.getOwnPropertyNames(proto).filter((name) => {
+                const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+                // Check if the descriptor exist, then if it's a function and finally
+                // if the function is owned by the class.
+                return (descriptor &&
+                    typeof descriptor.value === "function" &&
+                    Object.prototype.hasOwnProperty.call(proto, name));
+            });
+            methods.push(...ownMethods);
+            proto = Object.getPrototypeOf(proto);
+        }
+        // Add this to the registry
+        this.classes[constructor.name] = { class_: constructor, methods };
+        return constructor;
+    };
+    /**
+     * The definition of @field decorator that should be on top of any
+     * class' property that must be exposed to the Dagger API.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    field = (target, propertyKey) => {
+        // A placeholder to declare fields
+    };
+    /**
+     * The definition of @func decorator that should be on top of any
+     * class' method that must be exposed to the Dagger API.
+     */
+    func = (
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    target, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    propertyKey, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    descriptor) => {
+        // The logic is done in the object constructor since it's not possible to
+        // access the class parent's name from a method constructor without calling
+        // the method itself
+    };
+    /**
+     * 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
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        // Retrieve the resolver class from its key
+        const resolver = this.classes[object];
+        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_(...this.getArgOrder(resolver.class_).map((arg) => inputs[arg]));
+        }
+        // Safety check to make sure the method called exist in the class
+        // to avoid the app to crash brutally.
+        if (!resolver.methods.find((m) => m === method)) {
+            throw new UnknownDaggerError(`${method} is not registered in the resolver ${object}`, {});
+        }
+        // Instantiate the class
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let r = new resolver.class_();
+        // Apply state to the class
+        r = Object.assign(r, state);
+        // Order argument following the arg order and picking argument from the inputs map
+        const args = this.getArgOrder(r[method]).map((arg) => inputs[arg]);
+        // Execute and return the result
+        return await r[method](...args);
+    }
+    /**
+     * Get the order of argument by reading its content and create an array of its argument
+     * We cannot use r[method].prototype because it can be empty depending on the loading.
+     * Note(TomChv): This is a workaround until we find something more accurate.
+     * @param fct
+     * @private
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getArgOrder(fct) {
+        const fnStr = fct
+            .toString()
+            .replace(/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm, "");
+        return (fnStr
+            .slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")"))
+            .match(/\b(\w+)\b(?:(?=\s*[:=?]|,\s*|$))/g) ?? []);
+    }
+}
+/**
+ * The default registry used in any module.
+ */
+export const registry = new Registry();

package/dist/introspector/scanner/metadata.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Metadata of a variable (called symbol in the Typescript compiler)
+ */
+export type SymbolMetadata = {
+    name: string;
+    description: string;
+    typeName: string;
+};
+/**
+ * Metadata of a function or method parameter.
+ */
+export type ParamMetadata = SymbolMetadata & {
+    optional: boolean;
+    defaultValue?: string;
+};
+/**
+ * Metadata of a function's signature.
+ */
+export type SignatureMetadata = {
+    params: ParamMetadata[];
+    returnType: string;
+};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/introspector/scanner/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/metadata.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG;IAC3C,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA"}

package/dist/introspector/scanner/metadata.js

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

package/dist/introspector/scanner/scan.d.ts

@@ -0,0 +1,17 @@
+import { ClassTypeDef, FunctionTypedef } from "./typeDefs.js";
+export type ScanResult = {
+    classes: ClassTypeDef[];
+    functions: FunctionTypedef[];
+};
+/**
+ * Scan the list of Typescript File using the Typescript compiler API.
+ *
+ * This function introspect files and returns metadata of their class and
+ * functions that should be exposed to the Dagger API.
+ *
+ * WARNING(28/11/23): This does NOT include arrow style function.
+ *
+ * @param files List of Typescript files to introspect.
+ */
+export declare function scan(files: string[]): ScanResult;
+//# sourceMappingURL=scan.d.ts.map

package/dist/introspector/scanner/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/scan.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EAIZ,eAAe,EAChB,MAAM,eAAe,CAAA;AAStB,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,SAAS,EAAE,eAAe,EAAE,CAAA;CAC7B,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,UAAU,CA6BhD"}

package/dist/introspector/scanner/scan.js

@@ -0,0 +1,158 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../common/errors/UnknownDaggerError.js";
+import { serializeSignature, serializeSymbol } from "./serialize.js";
+import { isFunction, isObject, isOptional, isPublicProperty, typeNameToTypedef, } from "./utils.js";
+/**
+ * Scan the list of Typescript File using the Typescript compiler API.
+ *
+ * This function introspect files and returns metadata of their class and
+ * functions that should be exposed to the Dagger API.
+ *
+ * WARNING(28/11/23): This does NOT include arrow style function.
+ *
+ * @param files List of Typescript files to introspect.
+ */
+export function scan(files) {
+    if (files.length === 0) {
+        throw new UnknownDaggerError("no files to introspect found", {});
+    }
+    // Interpret the given typescript source files.
+    const program = ts.createProgram(files, { experimentalDecorators: true });
+    const checker = program.getTypeChecker();
+    const metadata = {
+        classes: [],
+        functions: [],
+    };
+    for (const file of program.getSourceFiles()) {
+        // Ignore type declaration files.
+        if (file.isDeclarationFile) {
+            continue;
+        }
+        ts.forEachChild(file, (node) => {
+            // Handle class
+            if (ts.isClassDeclaration(node) && isObject(node)) {
+                metadata.classes.push(introspectClass(checker, node));
+            }
+        });
+    }
+    return metadata;
+}
+/**
+ * Introspect a class and return its metadata.
+ *
+ * This function goes throw all class' method that have the @fct decorator
+ * and all its public properties.
+ *
+ * This function throws an error if it cannot read its symbol.
+ *
+ * @param checker The typescript compiler checker.
+ * @param node The class to check.
+ */
+function introspectClass(checker, node) {
+    // Throw error if node.name is undefined because we cannot scan its symbol.
+    if (!node.name) {
+        throw new UnknownDaggerError(`could not introspect class: ${node}`, {});
+    }
+    // Retrieve class symbol.
+    const classSymbol = checker.getSymbolAtLocation(node.name);
+    if (!classSymbol) {
+        throw new UnknownDaggerError(`could not get class symbol: ${node.name.getText()}`, {});
+    }
+    // Serialize class symbol to extract name and doc.
+    const { name, description } = serializeSymbol(checker, classSymbol);
+    // Create metadata object.
+    const metadata = {
+        name,
+        description,
+        constructor: undefined,
+        fields: [],
+        methods: [],
+    };
+    // Loop through all members in the class to get their metadata.
+    node.members.forEach((member) => {
+        // Handle constructor
+        if (ts.isConstructorDeclaration(member)) {
+            metadata.constructor = introspectConstructor(checker, member);
+        }
+        // Handle method from the class.
+        if (ts.isMethodDeclaration(member) && isFunction(member)) {
+            metadata.methods.push(introspectMethod(checker, member));
+        }
+        // Handle public properties from the class.
+        if (ts.isPropertyDeclaration(member) && isPublicProperty(member)) {
+            // Handle properties
+            metadata.fields.push(introspectProperty(checker, member));
+        }
+    });
+    return metadata;
+}
+/**
+ * Introspect a property from a class and return its metadata.
+ *
+ * This function throws an error if it cannot retrieve the property symbols.
+ *
+ * @param checker The typescript compiler checker.
+ * @param property The method to check.
+ */
+function introspectProperty(checker, property) {
+    const propertySymbol = checker.getSymbolAtLocation(property.name);
+    if (!propertySymbol) {
+        throw new UnknownDaggerError(`could not get property symbol: ${property.name.getText()}`, {});
+    }
+    const { name, typeName, description } = serializeSymbol(checker, propertySymbol);
+    return { name, description, typeDef: typeNameToTypedef(typeName) };
+}
+/**
+ * Introspect the constructor of the class and return its metadata.
+ */
+function introspectConstructor(checker, constructor) {
+    const args = constructor.parameters.map((param) => {
+        const paramSymbol = checker.getSymbolAtLocation(param.name);
+        if (!paramSymbol) {
+            throw new UnknownDaggerError(`could not get constructor param: ${param.name.getText()}`, {});
+        }
+        const { name, typeName, description } = serializeSymbol(checker, paramSymbol);
+        const { optional, defaultValue } = isOptional(paramSymbol);
+        return {
+            name,
+            description,
+            typeDef: typeNameToTypedef(typeName),
+            optional,
+            defaultValue,
+        };
+    });
+    return { args };
+}
+/**
+ * Introspect a method from a class and return its metadata.
+ *
+ * This function first retrieve the symbol of the function signature and then
+ * loop on its parameters to get their metadata.
+ *
+ * This function throws an error if it cannot retrieve the method symbols.
+ *
+ * @param checker The typescript compiler checker.
+ * @param method The method to check.
+ */
+function introspectMethod(checker, method) {
+    const methodSymbol = checker.getSymbolAtLocation(method.name);
+    if (!methodSymbol) {
+        throw new UnknownDaggerError(`could not get method symbol: ${method.name.getText()}`, {});
+    }
+    const methodMetadata = serializeSymbol(checker, methodSymbol);
+    const methodSignature = methodMetadata.type
+        .getCallSignatures()
+        .map((methodSignature) => serializeSignature(checker, methodSignature))[0];
+    return {
+        name: methodMetadata.name,
+        description: methodMetadata.description,
+        args: methodSignature.params.map(({ name, typeName, description, optional, defaultValue }) => ({
+            name,
+            typeDef: typeNameToTypedef(typeName),
+            description,
+            optional,
+            defaultValue,
+        })),
+        returnType: typeNameToTypedef(methodSignature.returnType),
+    };
+}

package/dist/introspector/scanner/serialize.d.ts

@@ -0,0 +1,34 @@
+import ts from "typescript";
+import { SignatureMetadata, SymbolMetadata } from "./metadata.js";
+/**
+ * Convert the function signature from the compiler API into a lighter data type.
+ *
+ * This functions returns the params serialized and its returns type.
+ *
+ * @param checker The typescript compiler checker.
+ * @param signature The signature to convert.
+ */
+export declare function serializeSignature(checker: ts.TypeChecker, signature: ts.Signature): SignatureMetadata;
+/**
+ * Convert the Typescript symbol from the compiler API into a lighter data type.
+ *
+ * This function returns the name of the symbol, with its typename and its
+ * documentation.
+ * This function also returns the actual Typescript type for additional
+ * introspection.
+ *
+ * @param checker The typescript compiler checker.
+ * @param symbol The type to convert.
+ */
+export declare function serializeSymbol(checker: ts.TypeChecker, symbol: ts.Symbol): SymbolMetadata & {
+    type: ts.Type;
+};
+/**
+ * Convert the Typescript type from the compiler API into a readable textual
+ * type.
+ *
+ * @param checker The typescript compiler checker.
+ * @param type The type to convert.
+ */
+export declare function serializeType(checker: ts.TypeChecker, type: ts.Type): string;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/introspector/scanner/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGjE;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,SAAS,EAAE,EAAE,CAAC,SAAS,GACtB,iBAAiB,CAanB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,MAAM,EAAE,EAAE,CAAC,MAAM,GAChB,cAAc,GAAG;IAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAA;CAAE,CAkBpC;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAS5E"}

package/dist/introspector/scanner/serialize.js

@@ -0,0 +1,62 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../common/errors/UnknownDaggerError.js";
+import { isOptional } from "./utils.js";
+/**
+ * Convert the function signature from the compiler API into a lighter data type.
+ *
+ * This functions returns the params serialized and its returns type.
+ *
+ * @param checker The typescript compiler checker.
+ * @param signature The signature to convert.
+ */
+export function serializeSignature(checker, signature) {
+    return {
+        params: signature.parameters.map((param) => {
+            const { optional, defaultValue } = isOptional(param);
+            return {
+                ...serializeSymbol(checker, param),
+                optional,
+                defaultValue,
+            };
+        }),
+        returnType: serializeType(checker, signature.getReturnType()),
+    };
+}
+/**
+ * Convert the Typescript symbol from the compiler API into a lighter data type.
+ *
+ * This function returns the name of the symbol, with its typename and its
+ * documentation.
+ * This function also returns the actual Typescript type for additional
+ * introspection.
+ *
+ * @param checker The typescript compiler checker.
+ * @param symbol The type to convert.
+ */
+export function serializeSymbol(checker, symbol) {
+    if (!symbol.valueDeclaration) {
+        throw new UnknownDaggerError("could not find symbol value declaration", {});
+    }
+    const type = checker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
+    return {
+        name: symbol.getName(),
+        description: ts.displayPartsToString(symbol.getDocumentationComment(checker)),
+        typeName: serializeType(checker, type),
+        type,
+    };
+}
+/**
+ * Convert the Typescript type from the compiler API into a readable textual
+ * type.
+ *
+ * @param checker The typescript compiler checker.
+ * @param type The type to convert.
+ */
+export function serializeType(checker, type) {
+    const strType = checker.typeToString(type);
+    // Remove Promise<> wrapper around type if it's a promise.
+    if (strType.startsWith("Promise")) {
+        return strType.substring("Promise<".length, strType.length - 1);
+    }
+    return strType;
+}

package/dist/introspector/scanner/typeDefs.d.ts

@@ -0,0 +1,70 @@
+import { TypeDefKind } from "../../api/client.gen.js";
+/**
+ * Base type of argument, field or return type.
+ */
+export type BaseTypeDef = {
+    kind: TypeDefKind;
+};
+/**
+ * Extends the base type def if it's an object to add its name.
+ */
+export type ObjectTypeDef = BaseTypeDef & {
+    kind: TypeDefKind.Objectkind;
+    name: string;
+};
+/**
+ * Extends the base if it's a list to add its subtype.
+ */
+export type ListTypeDef = BaseTypeDef & {
+    kind: TypeDefKind.Listkind;
+    typeDef: TypeDef<TypeDefKind>;
+};
+/**
+ * A generic TypeDef that will dynamically add necessary properties
+ * depending on its type.
+ *
+ * If it's type of kind list, it transforms the BaseTypeDef into an ObjectTypeDef.
+ * If it's a type of kind list, it transforms the BaseTypeDef into a ListTypeDef.
+ */
+export type TypeDef<T extends BaseTypeDef["kind"]> = T extends TypeDefKind.Objectkind ? ObjectTypeDef : T extends TypeDefKind.Listkind ? ListTypeDef : BaseTypeDef;
+/**
+ * The type of field in a class
+ */
+export type FieldTypeDef = {
+    name: string;
+    description: string;
+    typeDef: TypeDef<TypeDefKind>;
+};
+/**
+ * The type of function argument in a method or function.
+ */
+export type FunctionArg = {
+    name: string;
+    description: string;
+    optional: boolean;
+    defaultValue?: string;
+    typeDef: TypeDef<TypeDefKind>;
+};
+/**
+ * The type of function, it can be a method from a class or an actual function.
+ */
+export type FunctionTypedef = {
+    name: string;
+    description: string;
+    args: FunctionArg[];
+    returnType: TypeDef<TypeDefKind>;
+};
+export type ConstructorTypeDef = {
+    args: FunctionArg[];
+};
+/**
+ * A type of Class.
+ */
+export type ClassTypeDef = {
+    name: string;
+    description: string;
+    fields: FieldTypeDef[];
+    constructor?: ConstructorTypeDef;
+    methods: FunctionTypedef[];
+};
+//# sourceMappingURL=typeDefs.d.ts.map

package/dist/introspector/scanner/typeDefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeDefs.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/typeDefs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAErD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,WAAW,CAAA;CAClB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG;IACxC,IAAI,EAAE,WAAW,CAAC,UAAU,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG;IACtC,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAA;IAC1B,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;CAC9B,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,IAC/C,CAAC,SAAS,WAAW,CAAC,UAAU,GAC5B,aAAa,GACb,CAAC,SAAS,WAAW,CAAC,QAAQ,GAC9B,WAAW,GACX,WAAW,CAAA;AAEjB;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;CAC9B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;CAC9B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,WAAW,EAAE,CAAA;IACnB,UAAU,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,WAAW,EAAE,CAAA;CACpB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,YAAY,EAAE,CAAA;IACtB,WAAW,CAAC,EAAE,kBAAkB,CAAA;IAChC,OAAO,EAAE,eAAe,EAAE,CAAA;CAC3B,CAAA"}

package/dist/introspector/scanner/typeDefs.js

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

package/dist/introspector/scanner/utils.d.ts

@@ -0,0 +1,62 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../api/client.gen.js";
+import { TypeDef } from "./typeDefs.js";
+/**
+ * Return true if the given class declaration has the decorator @obj on
+ * top of its declaration.
+ * @param object
+ */
+export declare function isObject(object: ts.ClassDeclaration): boolean;
+/**
+ * Return true if the given method has the decorator @fct on top
+ * of its declaration.
+ *
+ * @param method The method to check
+ */
+export declare function isFunction(method: ts.MethodDeclaration): boolean;
+/**
+ * Return true if the given property is public.
+ *
+ * This function actually in work the reverse, it checks if the property
+ * isn't private nor protected.
+ *
+ * It returns true if the property has no modifiers since no keyword
+ * has been set on the property.
+ *
+ * Example
+ * ```
+ * class Human {
+ *     private age = 22 // Return false
+ *     protected familyName = "Doe" // Return false
+ *
+ *     @field
+ *     name = "John" // Return true
+ *
+ *     city = "Paris" // Return false because there's no decorator
+ * }
+ * ```
+ *
+ * @param property The property to check on.
+ */
+export declare function isPublicProperty(property: ts.PropertyDeclaration): boolean;
+type OptionalValue = {
+    optional: boolean;
+    defaultValue?: string;
+};
+/**
+ * Return true if the parameter is optional.
+ *
+ * This includes both optional value defines with `?` and value that
+ * have a default value.
+ *
+ * If there's a default value, its expression is returned in the result.
+ *
+ * @param param The param to check.
+ */
+export declare function isOptional(param: ts.Symbol): OptionalValue;
+/**
+ * Convert a typename into a Dagger Typedef using dynamic typing.
+ */
+export declare function typeNameToTypedef(typeName: string): TypeDef<TypeDefKind>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/introspector/scanner/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,gBAAgB,GAAG,OAAO,CAM7D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,iBAAiB,GAAG,OAAO,CAKhE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,EAAE,CAAC,mBAAmB,GAAG,OAAO,CAsB1E;AAED,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,GAAG,aAAa,CAwB1D;AAaD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAyBxE"}