@taqueria/plugin-contract-types 0.8.4 → 0.13.16

package/index.js

@@ -1,882 +1,78 @@
-var $3ymtt$taquerianodesdk = require("@taqueria/node-sdk");
-var $3ymtt$fastglob = require("fast-glob");
-var $3ymtt$path = require("path");
-var $3ymtt$fs = require("fs");
-var $3ymtt$util = require("util");
-var $3ymtt$taquitomichelcodec = require("@taquito/michel-codec");
-
-function $parcel$interopDefault(a) {
-  return a && a.__esModule ? a.default : a;
-}
-
-
-
-
-
-
-const $3f5c875567479895$export$bd8d1d28710832a7 = (text)=>text.replace(/[^A-Za-z0-9]/g, "_").split("_").filter((x)=>x).map((x)=>x[0].toUpperCase() + x.substring(1)).join("");
-
-
-
-class $901f5cf476ef87a5$export$d214d56e7a53a664 {
-    constructor(message, data){
-        this.message = message;
-        this.data = data;
-        this.name = `GenerateApiError`;
-        console.error(`❌ GenerateApiError: ${message}`, data);
-    }
-}
-const $901f5cf476ef87a5$export$16bf6fe03653420f = (value, message)=>{
-    console.error(message, {
-        value: value
-    });
-};
-const $901f5cf476ef87a5$export$37679993c4e6bc41 = (out, x)=>{
-    out.push(...x);
-    return out;
-}; // const reduceFlatMapTest = () => {
- //     const items = [['a'], ['b']];
- //     const itemsFlat = items.reduce(reduceFlatMap);
- // };
-
-
-
-const $b95e97a0bb3bf047$var$toDebugSource = (node)=>{
-    return JSON.stringify(node);
-};
-const $b95e97a0bb3bf047$export$cc65da7b09dcddd7 = (storage)=>{
-    const fields = storage.args.map((x)=>$b95e97a0bb3bf047$var$visitVar(x)).reduce((0, $901f5cf476ef87a5$export$37679993c4e6bc41), []);
-    if (fields.length === 1 && !fields[0].name) return {
-        storage: fields[0].type
-    };
-    return {
-        storage: {
-            kind: `object`,
-            raw: storage,
-            fields: fields
-        }
-    };
-};
-const $b95e97a0bb3bf047$export$5c00959a6ba200c1 = (parameter)=>{
-    return {
-        methods: parameter.args.map((x)=>$b95e97a0bb3bf047$var$visitContractParameterEndpoint(x)).reduce((0, $901f5cf476ef87a5$export$37679993c4e6bc41), [])
-    };
-};
-const $b95e97a0bb3bf047$var$visitContractParameterEndpoint = (node)=>{
-    // console.log('visitContractParameterEndpoint', { node });
-    // Sub endpoints (i.e. admin endpoints that are imported)
-    if (node.prim === `or`) return node.args.map((x)=>$b95e97a0bb3bf047$var$visitContractParameterEndpoint(x)).reduce((0, $901f5cf476ef87a5$export$37679993c4e6bc41), []);
-    // Sub endpoints as a list with a single or (i.e. admin endpoints that are imported)
-    if (node.prim === `list` && node.args.length === 1 && node.args[0]?.prim === `or`) return node.args.map((x)=>$b95e97a0bb3bf047$var$visitContractParameterEndpoint(x)).reduce((0, $901f5cf476ef87a5$export$37679993c4e6bc41), []);
-    const nameRaw = node.annots?.[0];
-    const name = nameRaw?.startsWith("%") ? nameRaw.substr(1) : null;
-    if (!name) {
-        console.warn(`Unknown method: ${node.prim}`, {
-            node: node,
-            args: node.args
-        });
-        return [];
-    }
-    const nodeType = $b95e97a0bb3bf047$var$visitType(node, {
-        ignorePairName: node.prim === "pair"
-    });
-    // Method args are usually objects
-    if (nodeType.kind === "object") return [
-        {
-            name: name,
-            args: nodeType.fields
-        }
-    ];
-    // Simple methods can have a single unnamed argument
-    return [
-        {
-            name: name,
-            args: [
-                {
-                    type: nodeType
-                }
-            ]
-        }
-    ];
-};
-const $b95e97a0bb3bf047$var$visitVar = (node)=>{
-    const name = `annots` in node && node.annots?.length === 1 ? node.annots[0].substr(1) : undefined;
-    const type = $b95e97a0bb3bf047$var$visitType(node);
-    return [
-        {
-            name: name,
-            type: type
-        }
-    ];
-};
-const $b95e97a0bb3bf047$var$visitType = (node, options)=>{
-    // console.log('visitType', { node });
-    // const debug_source = toDebugSource(node);
-    // if (typeof node === `string`) {
-    //     return { kind: `value`, raw: node, value: node, typescriptType: `string` };
-    // }
-    if (!(`prim` in node)) {
-        // Unknown
-        console.error(`visitType no prim`, {
-            node: node
-        });
-        return {
-            kind: `unknown`,
-            raw: node
-        };
-    }
-    // Union
-    if (node.prim === `or`) {
-        const unionVars = node.args.map((x)=>$b95e97a0bb3bf047$var$visitVar(x)).reduce((0, $901f5cf476ef87a5$export$37679993c4e6bc41), []).map((x)=>x);
-        // Flatten with child unions
-        const union = unionVars.map((x)=>!x.name && x.type.kind === "union" ? x.type.union : [
-                x
-            ]).reduce((0, $901f5cf476ef87a5$export$37679993c4e6bc41), []);
-        // const union = unionVars.map(x=>x.type);
-        // const union = unionVars.map(x => x.type);
-        // Flatten with child unions
-        // const rightSide = union[1];
-        // if (rightSide.kind === `union`) {
-        //     union.pop();
-        //     union.push(...rightSide.union);
-        // }
-        if (union.some((x)=>!x)) throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`or: Some fields are null`, {
-            node: node
-        });
-        return {
-            kind: `union`,
-            raw: node,
-            union: union
-        };
-    }
-    // Intersect
-    if (node.prim === `pair`) {
-        const fields = node.args.map((x)=>$b95e97a0bb3bf047$var$visitVar(x)).reduce((0, $901f5cf476ef87a5$export$37679993c4e6bc41), []);
-        if (fields.some((x)=>!x)) throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`pair: Some fields are null`, {
-            node: node,
-            args: node.args,
-            fields: fields
-        });
-        // Disabled Check: Apparently pairs can have more than 2 items
-        // if (fields.length !== 2) {
-        //     throw new GenerateApiError(`pair: Expected 2 items`, { node, length: fields.length, fields });
-        // }
-        // Flatten with unnamed child pairs
-        const fieldsFlat = fields.map((x)=>(!x.name || options?.ignorePairName) && x.type.kind === "object" ? x.type.fields : [
-                x
-            ]).reduce((0, $901f5cf476ef87a5$export$37679993c4e6bc41), []);
-        return {
-            kind: `object`,
-            raw: node,
-            fields: fieldsFlat
-        };
-    }
-    // list
-    if (node.prim === `list` || node.prim === `set`) {
-        if (node.args.length !== 1) throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`list does not have 1 arg`, {
-            node: node,
-            args: node.args
-        });
-        const arrayItem = $b95e97a0bb3bf047$var$visitType(node.args[0]);
-        if (!arrayItem) throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`arrayItem are null`, {
-            node: node,
-            args: node.args,
-            arrayItem: arrayItem
-        });
-        return {
-            kind: `array`,
-            raw: node,
-            array: {
-                item: arrayItem
-            }
-        };
-    }
-    // map
-    if (node.prim === `map` || node.prim === `big_map`) {
-        if (node.args.length !== 2) throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`map does not have 2 args`, {
-            node: node,
-            args: node.args
-        });
-        const mapKey = $b95e97a0bb3bf047$var$visitType(node.args[0]);
-        const mapValue = $b95e97a0bb3bf047$var$visitType(node.args[1]);
-        if (!mapKey || !mapValue) throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`map is missing key or value`, {
-            node: node,
-            args: node.args,
-            mapKey: mapKey,
-            mapValue: mapValue
-        });
-        return {
-            kind: `map`,
-            raw: node,
-            map: {
-                key: mapKey,
-                value: mapValue,
-                isBigMap: node.prim === `big_map`
-            }
-        };
-    }
-    // option
-    if (node.prim === `option`) return {
-        ...$b95e97a0bb3bf047$var$visitType(node.args[0]),
-        optional: true
-    };
-    // boolean
-    if (node.prim === `bool`) return {
-        kind: `value`,
-        raw: node,
-        value: node.prim,
-        typescriptType: `boolean`
-    };
-    // numbers
-    if (node.prim === `nat` || node.prim === `int` || node.prim === `mutez`) return {
-        kind: `value`,
-        raw: node,
-        value: node.prim,
-        typescriptType: `number`
-    };
-    // Date
-    if (node.prim === `timestamp`) return {
-        kind: `value`,
-        raw: node,
-        value: node.prim,
-        typescriptType: `Date`
-    };
-    // strings
-    if (node.prim === `address` || node.prim === `key` || node.prim === `key_hash` || node.prim === `chain_id` || node.prim === `string` || node.prim === `signature` || node.prim === `ticket` || node.prim === `bls12_381_fr` || node.prim === `bls12_381_g1` || node.prim === `bls12_381_g2` || node.prim === `sapling_state` || node.prim === `sapling_transaction` || node.prim === `contract`) return {
-        kind: `value`,
-        raw: node,
-        value: node.prim,
-        typescriptType: `string`
-    };
-    // void
-    if (node.prim === `unit`) return {
-        kind: `unit`,
-        raw: node
-    };
-    // bytes?
-    if (node.prim === `bytes`) return {
-        kind: `value`,
-        raw: node,
-        value: node.prim,
-        typescriptType: `string`
-    };
-    // misc?
-    if (node.prim === `lambda` || node.prim === `operation`) return {
-        kind: `value`,
-        raw: node,
-        value: node.prim,
-        typescriptType: `string`
-    };
-    // chest
-    if (node.prim === "chest" || node.prim === "chest_key") return {
-        kind: `value`,
-        raw: node,
-        value: node.prim,
-        typescriptType: `string`
-    };
-    // never
-    if (node.prim === `never`) return {
-        kind: `never`,
-        raw: node
-    };
-    // Unknown
-    (0, $901f5cf476ef87a5$export$16bf6fe03653420f)(node, `Unknown type`);
-    throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`Unknown type`, {
-        node: node
-    });
-};
-
-
-
-const $4e7cd4eb63db9934$export$eb0413f5ee90780 = (methods, storage)=>{
-    const getSchemaObjectType = (vars)=>{
-        // console.log('getSchemaObjectType', { vars });
-        if (vars.some((x)=>!x)) throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`getSchemaObjectType has null vars`, {
-            vars: vars
-        });
-        return vars.reduce((out, x, i)=>{
-            out[x.name ?? i] = getSchemaType(x.type);
-            return out;
-        }, {});
-    };
-    const getSchemaType = (t)=>{
-        // console.log('getSchemaType', { t });
-        return ((((((t.kind === `value` && t.value ? t.value : null) ?? (t.kind === `array` && t.array ? [
-            getSchemaType(t.array.item)
-        ] : null)) ?? (t.kind === `map` && t.map ? [
-            `map`,
-            getSchemaType(t.map.key),
-            getSchemaType(t.map.value)
-        ] : null)) ?? (t.kind === `object` && t.fields ? getSchemaObjectType(t.fields) : null)) ?? (t.kind === `unit` ? `unit` : null)) ?? (t.kind === `never` ? `never` : null)) ?? `${t.raw}`;
-    };
-    const schemaMethods = methods.reduce((out, x)=>{
-        // console.log('schemaMethods', { x });
-        out[x.name] = {
-            params: x.args.length === 1 && !x.args[0].name ? getSchemaType(x.args[0].type) : getSchemaObjectType(x.args ?? [])
-        };
-        return out;
-    }, {});
-    const schemaStorage = getSchemaType(storage.storage);
-    return {
-        methods: schemaMethods,
-        storage: schemaStorage
-    };
-};
-
-
-
-const $8fdd19ff0013f28e$export$d355209543d39bc0 = (storage, methods, contractName, parsedContract, protocol, typeAliasData, typeUtilsData)=>{
-    const usedStrictTypes = [];
-    const addTypeAlias = (strictType)=>{
-        if (!usedStrictTypes.some((x)=>x.aliasType === strictType.aliasType)) usedStrictTypes.push(strictType);
-    };
-    // Not really tabs :)
-    const tabs = (indent)=>Array(indent).fill(`    `).join(``);
-    const toIndentedItems = (indent, delimeters, items)=>{
-        return `
-${tabs(indent + 1)}${items.join(`${delimeters.afterItem ?? ``}
-${tabs(indent + 1)}${delimeters.beforeItem ?? ``}`)}
-${tabs(indent)}`;
-    };
-    const typeToCode = (t, indent)=>{
-        if (t.kind === `value`) {
-            // return `${t.typescriptType}`;
-            const prim = `prim` in t.raw ? t.raw.prim : `unknown`;
-            // Strict mode
-            if (t.typescriptType === `boolean` || t.typescriptType === `string` && prim === `string`) return `${t.typescriptType}`;
-            if (t.typescriptType === "number") {
-                const simpleBaseType = `string | BigNumber | number`;
-                const typeAlias = {
-                    aliasType: prim,
-                    simpleTypeDefinition: `type ${prim} = ${simpleBaseType};`,
-                    simpleTypeImports: [
-                        {
-                            name: "BigNumber",
-                            isDefault: true,
-                            from: "bignumber.js"
-                        }
-                    ]
-                };
-                addTypeAlias(typeAlias);
-                return typeAlias.aliasType;
-            }
-            const simpleBaseType = t.typescriptType === "Date" ? "Date | string" : t.typescriptType;
-            const typeAlias = {
-                aliasType: prim,
-                simpleTypeDefinition: `type ${prim} = ${simpleBaseType};`
-            };
-            addTypeAlias(typeAlias);
-            return typeAlias.aliasType;
-        }
-        if (t.kind === `array`) return `Array<${typeToCode(t.array.item, indent)}>`;
-        if (t.kind === `map`) {
-            const typeAlias = t.map.isBigMap ? {
-                aliasType: `BigMap`,
-                simpleTypeDefinition: "type BigMap<K, T> = MichelsonMap<K, T>;",
-                simpleTypeImports: [
-                    {
-                        name: "MichelsonMap",
-                        from: "@taquito/taquito"
-                    }
-                ]
-            } : {
-                aliasType: `MMap`,
-                simpleTypeDefinition: "type MMap<K, T> = MichelsonMap<K, T>;",
-                simpleTypeImports: [
-                    {
-                        name: "MichelsonMap",
-                        from: "@taquito/taquito"
-                    }
-                ]
-            };
-            addTypeAlias(typeAlias);
-            return `${typeAlias.aliasType}<${typeToCode(t.map.key, indent)}, ${typeToCode(t.map.value, indent)}>`;
-        }
-        if (t.kind === `object`) return `{${toIndentedItems(indent, {}, t.fields.map((a, i)=>varToCode(a, i, indent + 1) + `;`))}}`;
-        if (t.kind === `union`) {
-            const getUnionItem = (a, i)=>{
-                const itemCode = `${varToCode(a, i, indent + 1)}`;
-                // Keep on single line if already on single line
-                if (!itemCode.includes(`\n`)) return `{ ${itemCode} }`;
-                // Indent if multi-line (and remake with extra indent)
-                return `{${toIndentedItems(indent + 1, {}, [
-                    `${varToCode(a, i, indent + 2)}`
-                ])}}`;
-            };
-            return `(${toIndentedItems(indent, {
-                beforeItem: `| `
-            }, t.union.map(getUnionItem))})`;
-        }
-        if (t.kind === `unit`) {
-            const typeAlias = {
-                aliasType: `unit`,
-                simpleTypeDefinition: `type unit = (true | undefined);`
-            };
-            addTypeAlias(typeAlias);
-            return typeAlias.aliasType;
-        }
-        if (t.kind === `never`) return `never`;
-        if (t.kind === `unknown`) return `unknown`;
-        (0, $901f5cf476ef87a5$export$16bf6fe03653420f)(t, `Unknown type`);
-        throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`Unknown type node`, {
-            t: t
-        });
-    };
-    const varToCode = (t, i, indent, numberVarNamePrefix = "")=>{
-        return `${t.name ?? `${numberVarNamePrefix}${i}`}${t.type.optional ? `?` : ``}: ${typeToCode(t.type, indent)}`;
-    };
-    const argsToCode = (args, indent, asObject)=>{
-        if (args.length === 1) {
-            if (args[0].type.kind === `unit`) return ``;
-            return `${args[0].name ?? `param`}: ${typeToCode(args[0].type, indent + 1)}`;
-        }
-        const result = `${toIndentedItems(indent, {}, args.filter((x)=>x.name || x.type.kind !== `unit`).map((a, i)=>varToCode(a, i, indent + 1, asObject ? "" : "_") + `,`))}`;
-        if (asObject) return `params: {${result}}`;
-        return result;
-    };
-    const methodsToCode = (indent)=>{
-        const methodFields = methods.map((x)=>{
-            const methodCode = `${x.name}: (${argsToCode(x.args, indent + 1, false)}) => Promise<void>;`;
-            return methodCode;
-        });
-        const methodsTypeCode = `type Methods = {${toIndentedItems(indent, {}, methodFields)}};`;
-        return methodsTypeCode;
-    };
-    const methodsObjectToCode = (indent)=>{
-        const methodFields = methods.map((x)=>{
-            const methodCode = `${x.name}: (${argsToCode(x.args, indent + 1, true)}) => Promise<void>;`;
-            return methodCode;
-        });
-        const methodsTypeCode = `type MethodsObject = {${toIndentedItems(indent, {}, methodFields)}};`;
-        return methodsTypeCode;
-    };
-    const storageToCode = (indent)=>{
-        const storageTypeCode = `type Storage = ${typeToCode(storage.storage, indent)};`;
-        return storageTypeCode;
-    };
-    const methodsCode = methodsToCode(0);
-    const methodsObjectCode = methodsObjectToCode(0);
-    const storageCode = storageToCode(0);
-    // Simple type aliases
-    const simpleTypeMappingImportsAll = new Map(usedStrictTypes.map((x)=>x.simpleTypeImports ?? []).reduce((0, $901f5cf476ef87a5$export$37679993c4e6bc41), []).map((x)=>[
-            `${x?.from}:${x?.name}:${x?.isDefault}`,
-            x
-        ]));
-    const simpleTypeMappingImportsFrom = [
-        ...simpleTypeMappingImportsAll.values()
-    ].reduce((out, x)=>{
-        const entry = out[x.from] ?? (out[x.from] = {
-            names: []
-        });
-        if (x.isDefault) entry.default = x.name;
-        else entry.names.push(x.name);
-        entry.names.sort((a, b)=>a.localeCompare(b));
-        return out;
-    }, {});
-    const simpleTypeMappingImportsText = Object.keys(simpleTypeMappingImportsFrom).map((k)=>{
-        const entry = simpleTypeMappingImportsFrom[k];
-        const items = [
-            entry.default,
-            entry.names.length ? `{ ${entry.names.join(", ")} }` : ""
-        ].filter((x)=>x);
-        return `import ${items.join(", ")} from '${k}';\n`;
-    }).join("");
-    const simpleTypeMapping = usedStrictTypes.sort((a, b)=>a.aliasType.localeCompare(b.aliasType)).map((x)=>x.simpleTypeDefinition).join(`\n`);
-    const typeUtilsDefinitions = `import { ContractAbstractionFromContractType, WalletContractAbstractionFromContractType } from '${typeUtilsData.importPath}';`;
-    const typeAliasesDefinitions = typeAliasData.mode === "simple" ? `${simpleTypeMappingImportsText}${simpleTypeMapping}` : typeAliasData.mode === "local" ? typeAliasData.fileContent : `import { ${usedStrictTypes.map((x)=>x.aliasType).join(`, `)} } from '${typeAliasData.importPath}';`;
-    const contractTypeName = `${contractName}ContractType`;
-    const walletTypeName = `${contractName}WalletType`;
-    const codeName = `${contractName}Code`;
-    const typesFileContent = `
-${typeUtilsDefinitions}
-${typeAliasesDefinitions}
-
-${storageCode}
-
-${methodsCode}
-
-${methodsObjectCode}
-
-type contractTypes = { methods: Methods, methodsObject: MethodsObject, storage: Storage, code: { __type: '${codeName}', protocol: string, code: object[] } };
-export type ${contractTypeName} = ContractAbstractionFromContractType<contractTypes>;
-export type ${walletTypeName} = WalletContractAbstractionFromContractType<contractTypes>;
-`;
-    const contractCodeFileContent = `
-export const ${codeName}: { __type: '${codeName}', protocol: string, code: object[] } = {
-    __type: '${codeName}',
-    protocol: '${protocol.key}',
-    code: JSON.parse(\`${JSON.stringify(parsedContract)}\`)
-};
-`;
-    return {
-        typesFileContent: typesFileContent,
-        contractCodeFileContent: contractCodeFileContent,
-        storage: storageCode,
-        methods: methodsCode,
-        methodsObject: methodsObjectCode
-    };
-};
-
-
-const $38088c948e5b4cf5$var$parseContractWithMinimalProtocolLevel = (contractScript, format, contractLevelIndex)=>{
-    const contractLevels = [
-        {
-            name: "PsDELPH1",
-            key: $3ymtt$taquitomichelcodec.Protocol.PsDELPH1
-        },
-        {
-            name: "PtEdo2Zk",
-            key: $3ymtt$taquitomichelcodec.Protocol.PtEdo2Zk
-        },
-        {
-            name: "PsFLorena",
-            key: $3ymtt$taquitomichelcodec.Protocol.PsFLorena
-        }, 
-    ];
-    const protocol = contractLevels[contractLevelIndex];
-    if (!protocol) throw new (0, $901f5cf476ef87a5$export$d214d56e7a53a664)(`Could not parse contract script`, contractScript);
-    const p = new $3ymtt$taquitomichelcodec.Parser({
-        protocol: protocol.key
-    });
-    try {
-        const contract = format === "tz" ? p.parseScript(contractScript) : p.parseJSON(JSON.parse(contractScript));
-        if (contract) return {
-            contract: contract,
-            protocol: protocol
-        };
-    } catch  {
-    // Ignore parse errors
-    }
-    // Try again with next level
-    return $38088c948e5b4cf5$var$parseContractWithMinimalProtocolLevel(contractScript, format, contractLevelIndex + 1);
-};
-const $38088c948e5b4cf5$export$adc4e820bbd3332 = (contractScript, contractName, format, typeAliasData, typeUtilsData)=>{
-    const p = new $3ymtt$taquitomichelcodec.Parser({
-        protocol: $3ymtt$taquitomichelcodec.Protocol.PsFLorena
-    });
-    const { contract: contract , protocol: protocol  } = $38088c948e5b4cf5$var$parseContractWithMinimalProtocolLevel(contractScript, format, 0);
-    const contractStorage = contract.find((x)=>x.prim === `storage`);
-    const contractParameter = contract.find((x)=>x.prim === `parameter`);
-    const storageResult = contractStorage && (0, $b95e97a0bb3bf047$export$cc65da7b09dcddd7)(contractStorage);
-    const storage = storageResult ?? {
-        storage: {
-            kind: `object`,
-            raw: {
-                prim: `never`
-            },
-            fields: []
-        }
-    };
-    const parameterResult = contractParameter && (0, $b95e97a0bb3bf047$export$5c00959a6ba200c1)(contractParameter);
-    const methods = parameterResult?.methods ?? [];
-    // If there's only one entrypoint, then we call it "default"
-    if (methods.length === 1) methods[0].name = `default`;
-    const schemaOutput = (0, $4e7cd4eb63db9934$export$eb0413f5ee90780)(methods, storage);
-    const typescriptCode = (0, $8fdd19ff0013f28e$export$d355209543d39bc0)(storage, methods, contractName, contract, protocol, typeAliasData, typeUtilsData);
-    return {
-        schemaOutput: schemaOutput,
-        typescriptCodeOutput: typescriptCode,
-        parsedContract: contract,
-        minimalProtocol: protocol.key
-    };
-};
-
-
-const $7d27ec5ea3b0470e$export$4bf5db15180664ad = `
-import { BigNumber } from 'bignumber.js';
-import { MichelsonMap } from '@taquito/taquito';
-
-export type unit = (true | undefined) & { __type: 'unit' };
-
-export type address = string & { __type: 'address' };
-export type bytes = string & { __type: 'bytes' };
-export type contract = string & { __type: 'contract' };
-export type operation = string & { __type: 'operation' };
-export type key = string & { __type: 'key' };
-export type key_hash = string & { __type: 'key_hash' };
-export type signature = string & { __type: 'signature' };
-export type ticket = string & { __type: 'ticket' };
-
-export type timestamp = string & { __type: 'timestamp' };
-
-export type int = BigNumber & { __type: 'int' };
-export type nat = BigNumber & { __type: 'nat' };
-
-export type mutez = BigNumber & { __type: 'mutez' };
-export type tez = BigNumber & { __type: 'tez' };
-
-type MapKey = Array<any> | object | string | boolean | number;
-export type MMap<K extends MapKey, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => V };
-export type BigMap<K extends MapKey, V> = Omit<MichelsonMap<K, V>, 'get'> & { get: (key: K) => Promise<V> };
-
-export type chest = string & { __type: 'chest' };
-export type chest_key = string & { __type: 'chest_key' };
-
-const createStringTypeTas = <T extends string>() => {
-    return (value: string): T => value as T;
-};
-
-const createBigNumberTypeTas = <T extends BigNumber>() => {
-    return (value: number | BigNumber | string): T => new BigNumber(value) as T;
-};
-
-type asMapParamOf<K, V> = K extends string ? { [key: string]: V } | Array<{ key: K, value: V }>
-    : K extends number ? { [key: number]: V } | Array<{ key: K, value: V }>
-    : Array<{ key: K, value: V }>;
-
-function asMap<K extends MapKey, V>(value: asMapParamOf<K, V>): MMap<K, V> {
-    const m = new MichelsonMap<K, V>();
-    if (Array.isArray(value)) {
-        const vArray = value as Array<{ key: K, value: V }>;
-        vArray.forEach(x => m.set(x.key, x.value));
-    } else {
-        const vObject = value as { [key: string]: V };
-        Object.keys(vObject).forEach(key => m.set(key as unknown as K, vObject[key]));
-    }
-    return m as MMap<K, V>;
-}
-const asBigMap = <K extends MapKey, V>(value: asMapParamOf<K, V>) => asMap(value) as unknown as BigMap<K, V>;
-
-function add<T extends BigNumber>(a: T, b: T): T {
-    return a.plus(b) as T;
-}
-function subtract<T extends BigNumber>(a: T, b: T): T {
-    return a.minus(b) as T;
-}
-
-/** tas: Tezos 'as' casting for strict types */
-export const tas = {
-    address: createStringTypeTas<address>(),
-    bytes: createStringTypeTas<bytes>(),
-    contract: createStringTypeTas<contract>(),
-    chest: createStringTypeTas<chest>(),
-    chest_key: createStringTypeTas<chest_key>(),
-    timestamp: (value: string | Date): timestamp => new Date(value).toISOString() as timestamp,
-
-    int: createBigNumberTypeTas<int>(),
-    nat: createBigNumberTypeTas<nat>(),
-    mutez: createBigNumberTypeTas<mutez>(),
-    tez: createBigNumberTypeTas<tez>(),
-
-    map: asMap,
-    bigMap: asBigMap,
-
-    // Operations
-    add,
-    subtract,
-
-    // To number
-    number: (value: string | BigNumber) => Number(value + ''),
-};
-`;
-
-
-const $d6317276dd27d471$export$e9cf70f604100ab7 = `
-import { ContractAbstraction, ContractMethod, ContractMethodObject, ContractProvider, Wallet } from '@taquito/taquito';
-
-type BaseContractType = { methods: unknown, methodsObject: unknown, storage: unknown };
-
-type ContractMethodsOf<T extends ContractProvider | Wallet, TContract extends BaseContractType> = {
-[M in keyof TContract['methods']]:
-TContract['methods'][M] extends (...args: infer A) => unknown
-? (...args: A) => ContractMethod<T>
-: never
-};
-type ContractMethodsObjectsOf<T extends ContractProvider | Wallet, TContract extends BaseContractType> = {
-[M in keyof TContract['methodsObject']]:
-TContract['methodsObject'][M] extends (...args: infer A) => unknown
-? (...args: A) => ContractMethodObject<T>
-: never
-};
-type ContractStorageOf<TContract extends BaseContractType> = TContract['storage'];
-
-export type ContractAbstractionFromContractType<TContract extends BaseContractType> = 
-    ContractAbstraction<ContractProvider, 
-        ContractMethodsOf<ContractProvider, TContract>,
-        ContractMethodsObjectsOf<ContractProvider, TContract>,
-        {},
-        {},
-        ContractStorageOf<TContract>
-    >;
-
-export type WalletContractAbstractionFromContractType<TContract extends BaseContractType> = 
-    ContractAbstraction<Wallet, 
-        ContractMethodsOf<Wallet, TContract>,
-        ContractMethodsObjectsOf<Wallet, TContract>,
-        {},
-        {},
-        ContractStorageOf<TContract>
-    >;
-`;
-
-
-const $ce33c3ba360b60b0$var$fs = {
-    mkdir: (0, $3ymtt$util.promisify)((0, ($parcel$interopDefault($3ymtt$fs))).mkdir),
-    copyFile: (0, $3ymtt$util.promisify)((0, ($parcel$interopDefault($3ymtt$fs))).copyFile),
-    readdir: (0, $3ymtt$util.promisify)((0, ($parcel$interopDefault($3ymtt$fs))).readdir),
-    readFile: (0, $3ymtt$util.promisify)((0, ($parcel$interopDefault($3ymtt$fs))).readFile),
-    writeFile: (0, $3ymtt$util.promisify)((0, ($parcel$interopDefault($3ymtt$fs))).writeFile),
-    stat: (0, $3ymtt$util.promisify)((0, ($parcel$interopDefault($3ymtt$fs))).stat),
-    exists: (0, ($parcel$interopDefault($3ymtt$fs))).existsSync
-};
-const $ce33c3ba360b60b0$var$getAllFiles = async (rootPath, filter)=>{
-    const allFiles = [];
-    const getAllFilesRecursive = async (dirPath)=>{
-        let files = await $ce33c3ba360b60b0$var$fs.readdir(dirPath, {
-            withFileTypes: true
-        });
-        for (const f of files){
-            const subPath = (0, ($parcel$interopDefault($3ymtt$path))).resolve(dirPath, f.name);
-            if (f.isDirectory()) {
-                await getAllFilesRecursive(subPath);
-                continue;
-            }
-            if (!filter(subPath)) continue;
-            allFiles.push(subPath);
-        }
-    };
-    await getAllFilesRecursive(rootPath);
-    return allFiles;
-};
-const $ce33c3ba360b60b0$export$2ab4539ae1119673 = async ({ inputTzContractDirectory: inputTzContractDirectory , inputFiles: inputFiles , outputTypescriptDirectory: outputTypescriptDirectory , format: format , typeAliasMode: typeAliasMode  })=>{
-    console.log(`Generating Types: ${(0, ($parcel$interopDefault($3ymtt$path))).resolve(inputTzContractDirectory)} => ${(0, ($parcel$interopDefault($3ymtt$path))).resolve(outputTypescriptDirectory)}`);
-    const ext = "." + format;
-    const filesAll = await $ce33c3ba360b60b0$var$getAllFiles(inputTzContractDirectory, (x)=>x.endsWith(ext));
-    const files = inputFiles ? filesAll.filter((f)=>inputFiles.some((inputFile)=>f.endsWith(inputFile))) : filesAll;
-    console.log(`Contracts Found: ${[
-        ``,
-        ...files
-    ].join(`\n\t- `)}`);
-    const typeAliasImportPath = `@taquito/contract-type-generator`;
-    const typeAliasData = typeAliasMode === "local" ? {
-        mode: typeAliasMode,
-        fileContent: (0, $7d27ec5ea3b0470e$export$4bf5db15180664ad)
-    } : typeAliasMode === "file" ? {
-        mode: typeAliasMode,
-        importPath: `./type-aliases`
-    } : typeAliasMode === "library" ? {
-        mode: typeAliasMode,
-        importPath: typeAliasImportPath
-    } : {
-        mode: "simple"
-    };
-    if (typeAliasMode === "file") {
-        // Copy the type alias file
-        await $ce33c3ba360b60b0$var$fs.mkdir(outputTypescriptDirectory, {
-            recursive: true
-        });
-        await $ce33c3ba360b60b0$var$fs.writeFile((0, ($parcel$interopDefault($3ymtt$path))).join(outputTypescriptDirectory, "./type-aliases.ts"), (0, $7d27ec5ea3b0470e$export$4bf5db15180664ad));
-    }
-    // Copy the type utils file
-    const typeUtilsData = {
-        importPath: `./type-utils`
-    };
-    await $ce33c3ba360b60b0$var$fs.mkdir(outputTypescriptDirectory, {
-        recursive: true
-    });
-    await $ce33c3ba360b60b0$var$fs.writeFile((0, ($parcel$interopDefault($3ymtt$path))).join(outputTypescriptDirectory, "./type-utils.ts"), (0, $d6317276dd27d471$export$e9cf70f604100ab7));
-    for (const fullPath of files){
-        const fileRelativePath = fullPath.replace((0, ($parcel$interopDefault($3ymtt$path))).resolve(inputTzContractDirectory), "");
-        const fileName = fileRelativePath.replace(ext, "");
-        const inputFilePath = (0, ($parcel$interopDefault($3ymtt$path))).join(inputTzContractDirectory, fileRelativePath);
-        const typesOutputFilePath = (0, ($parcel$interopDefault($3ymtt$path))).join(outputTypescriptDirectory, fileRelativePath.replace(ext, `.types.ts`));
-        const codeContentOutputFilePath = (0, ($parcel$interopDefault($3ymtt$path))).join(outputTypescriptDirectory, fileRelativePath.replace(ext, `.code.ts`));
-        const schemaContentOutputFilePath = (0, ($parcel$interopDefault($3ymtt$path))).join(outputTypescriptDirectory, fileRelativePath.replace(ext, `.schema.json`));
-        console.log(`Processing ${fileRelativePath}...`);
-        try {
-            const contractTypeName = (0, $3f5c875567479895$export$bd8d1d28710832a7)(fileName);
-            const michelsonCode = await $ce33c3ba360b60b0$var$fs.readFile(inputFilePath, {
-                encoding: `utf8`
-            });
-            const { schemaOutput: schemaOutput , typescriptCodeOutput: { typesFileContent: typesFileContent , contractCodeFileContent: contractCodeFileContent  } ,  } = (0, $38088c948e5b4cf5$export$adc4e820bbd3332)(michelsonCode, contractTypeName, format, typeAliasData, typeUtilsData);
-            // Write output (ensure dir exists)
-            await $ce33c3ba360b60b0$var$fs.mkdir((0, ($parcel$interopDefault($3ymtt$path))).dirname(typesOutputFilePath), {
-                recursive: true
-            });
-            await $ce33c3ba360b60b0$var$fs.writeFile(typesOutputFilePath, typesFileContent);
-            await $ce33c3ba360b60b0$var$fs.writeFile(codeContentOutputFilePath, contractCodeFileContent);
-            const debugSchema = false;
-            if (debugSchema) await $ce33c3ba360b60b0$var$fs.writeFile(schemaContentOutputFilePath, JSON.stringify(schemaOutput, null, 2));
-        } catch (err) {
-            console.error(`❌ Could not process ${fileRelativePath}`, {
-                err: err
-            });
-        }
-    }
-};
-
-
-const $3beaa6d78a95a243$var$getContractAbspath = (contractFilename, parsedArgs)=>(0, $3ymtt$path.join)(parsedArgs.config.artifactsDir, /\.tz$/.test(contractFilename) ? contractFilename : `${contractFilename}.tz`);
-const $3beaa6d78a95a243$var$generateContractTypes = (parsedArgs)=>async (contractFilename)=>{
-        const contractAbspath = $3beaa6d78a95a243$var$getContractAbspath(contractFilename, parsedArgs);
-        await (0, $ce33c3ba360b60b0$export$2ab4539ae1119673)({
-            inputTzContractDirectory: parsedArgs.config.artifactsDir,
-            inputFiles: [
-                contractAbspath
-            ],
-            outputTypescriptDirectory: parsedArgs.typescriptDir || "types",
-            format: "tz",
-            typeAliasMode: parsedArgs.typeAliasMode ?? "file"
-        });
-        return `${contractFilename}: Types generated`;
-    };
-const $3beaa6d78a95a243$var$generateContractTypesAll = async (parsedArgs)=>{
-    const files = await (0, ($parcel$interopDefault($3ymtt$fastglob)))("**/*.tz", {
-        cwd: parsedArgs.config.artifactsDir
-    });
-    return await Promise.all(files.map($3beaa6d78a95a243$var$generateContractTypes(parsedArgs)));
-};
-const $3beaa6d78a95a243$export$3350b7b754d5c00c = (parsedArgs)=>{
-    parsedArgs.typescriptDir = parsedArgs.typescriptDir || "types";
-    console.log("generateTypes", {
-        typescriptDir: parsedArgs.typescriptDir
-    });
-    const p = parsedArgs.contract ? $3beaa6d78a95a243$var$generateContractTypes(parsedArgs)(parsedArgs.contract) : $3beaa6d78a95a243$var$generateContractTypesAll(parsedArgs);
-    return p.then((data)=>{
-        console.log(Array.isArray(data) ? data.join("\n") : data);
-    });
-};
-const $3beaa6d78a95a243$export$7191f9b9098a3ea4 = {
-    generateTypes: $3beaa6d78a95a243$export$3350b7b754d5c00c
-};
-
-
-(0, $3ymtt$taquerianodesdk.Plugin).create((i18n)=>({
-        alias: "contract-types",
-        schema: "1.0",
-        version: "0.1",
-        tasks: [
-            (0, $3ymtt$taquerianodesdk.Task).create({
-                task: "generate types",
-                command: "generate types [typescriptDir]",
-                description: "Generate types for a contract to be used with taquito",
-                positionals: [
-                    (0, $3ymtt$taquerianodesdk.PositionalArg).create({
-                        placeholder: "typescriptDir",
-                        description: "The output directory for the generated type files",
-                        defaultValue: "types"
-                    }), 
-                ],
-                options: [
-                    (0, $3ymtt$taquerianodesdk.Option).create({
-                        shortFlag: "t",
-                        flag: "typeAliasMode",
-                        choices: [
-                            "file",
-                            "simple"
-                        ],
-                        description: "The type aliases used in the generated types"
-                    }), 
-                ],
-                aliases: [
-                    "gen types",
-                    "gentypes"
-                ],
-                handler: "proxy"
-            }), 
-        ],
-        proxy: (0, $3beaa6d78a95a243$export$7191f9b9098a3ea4).generateTypes
-    }), process.argv);
-
-
-//# sourceMappingURL=index.js.map
+import {
+  generateContractTypesProcessContractFiles
+} from "./chunk-QSIV2OJS.js";
+import "./chunk-T4SGVAIL.js";
+
+// index.ts
+import { Option, Plugin, PositionalArg, Task } from "@taqueria/node-sdk";
+
+// tasks.ts
+import glob from "fast-glob";
+import { join } from "path";
+var getContractAbspath = (contractFilename, parsedArgs) => join(parsedArgs.config.artifactsDir, /\.tz$/.test(contractFilename) ? contractFilename : `${contractFilename}.tz`);
+var generateContractTypes = (parsedArgs) => async (contractFilename) => {
+  const contractAbspath = getContractAbspath(contractFilename, parsedArgs);
+  await generateContractTypesProcessContractFiles({
+    inputTzContractDirectory: parsedArgs.config.artifactsDir,
+    inputFiles: [contractAbspath],
+    outputTypescriptDirectory: parsedArgs.typescriptDir || "types",
+    format: "tz",
+    typeAliasMode: parsedArgs.typeAliasMode ?? "file"
+  });
+  return `${contractFilename}: Types generated`;
+};
+var generateContractTypesAll = async (parsedArgs) => {
+  const files = await glob("**/*.tz", { cwd: parsedArgs.config.artifactsDir });
+  return await Promise.all(files.map(generateContractTypes(parsedArgs)));
+};
+var generateTypes = (parsedArgs) => {
+  parsedArgs.typescriptDir = parsedArgs.typescriptDir || "types";
+  console.log("generateTypes", {
+    typescriptDir: parsedArgs.typescriptDir
+  });
+  const p = parsedArgs.contract ? generateContractTypes(parsedArgs)(parsedArgs.contract) : generateContractTypesAll(parsedArgs);
+  return p.then((data) => {
+    console.log(
+      Array.isArray(data) ? data.join("\n") : data
+    );
+  });
+};
+var tasks = {
+  generateTypes
+};
+
+// index.ts
+Plugin.create((i18n) => ({
+  alias: "contract-types",
+  schema: "1.0",
+  version: "0.1",
+  tasks: [
+    Task.create({
+      task: "generate types",
+      command: "generate types [typescriptDir]",
+      description: "Generate types for a contract to be used with taquito",
+      positionals: [
+        PositionalArg.create({
+          placeholder: "typescriptDir",
+          description: "The output directory for the generated type files",
+          defaultValue: "types"
+        })
+      ],
+      options: [
+        Option.create({
+          shortFlag: "t",
+          flag: "typeAliasMode",
+          choices: ["file", "simple"],
+          description: "The type aliases used in the generated types"
+        })
+      ],
+      aliases: ["gen types", "gentypes"],
+      handler: "proxy"
+    })
+  ],
+  proxy: tasks.generateTypes
+}), process.argv);
+export {
+  generateContractTypesProcessContractFiles
+};
+//# sourceMappingURL=index.js.map