@cosmwasm/ts-codegen 1.7.1 → 1.7.2

package/plugins/client.js

@@ -23,19 +23,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientPlugin = exports.TYPE = void 0;
+exports.ClientPlugin = void 0;
 const case_1 = require("case");
 const w = __importStar(require("wasm-ast-types"));
 const utils_1 = require("../utils");
 const wasm_ast_types_1 = require("wasm-ast-types");
 const plugin_base_1 = require("./plugin-base");
-exports.TYPE = "client";
 class ClientPlugin extends plugin_base_1.BuilderPluginBase {
     initContext(contract, options) {
-        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder?.builderContext);
     }
     async doRender(name, context) {
-        const { enabled } = this.option.client;
+        const { enabled } = this.options.client;
         if (!enabled) {
             return;
         }
@@ -65,8 +64,8 @@ class ClientPlugin extends plugin_base_1.BuilderPluginBase {
             if (children.length > 0) {
                 Client = (0, case_1.pascal)(`${name}Client`);
                 Instance = (0, case_1.pascal)(`${name}Interface`);
-                body.push(w.createExecuteInterface(context, Instance, this.option.client.execExtendsQuery ? ReadOnlyInstance : null, ExecuteMsg));
-                body.push(w.createExecuteClass(context, Client, Instance, this.option.client.execExtendsQuery ? QueryClient : null, ExecuteMsg));
+                body.push(w.createExecuteInterface(context, Instance, this.options.client.execExtendsQuery ? ReadOnlyInstance : null, ExecuteMsg));
+                body.push(w.createExecuteClass(context, Client, Instance, this.options.client.execExtendsQuery ? QueryClient : null, ExecuteMsg));
                 context.addProviderInfo(name, w.PROVIDER_TYPES.SIGNING_CLIENT_TYPE, Client, localname);
             }
         }
@@ -76,7 +75,7 @@ class ClientPlugin extends plugin_base_1.BuilderPluginBase {
         }
         return [
             {
-                type: exports.TYPE,
+                type: "client",
                 localname,
                 body,
             },

package/plugins/index.d.ts

@@ -1 +1,7 @@
 export * from "./plugin-base";
+export * from "./client";
+export * from "./react-query";
+export * from "./recoil";
+export * from "./message-builder";
+export * from "./message-composer";
+export * from "./types";

package/plugins/index.js

@@ -15,3 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./plugin-base"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./react-query"), exports);
+__exportStar(require("./recoil"), exports);
+__exportStar(require("./message-builder"), exports);
+__exportStar(require("./message-composer"), exports);
+__exportStar(require("./types"), exports);

package/plugins/message-builder.js

@@ -31,10 +31,10 @@ const wasm_ast_types_1 = require("wasm-ast-types");
 const plugin_base_1 = require("./plugin-base");
 class MessageBuilderPlugin extends plugin_base_1.BuilderPluginBase {
     initContext(contract, options) {
-        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder?.builderContext);
     }
     async doRender(name, context) {
-        const { enabled } = this.option.messageBuilder;
+        const { enabled } = this.options.messageBuilder;
         if (!enabled) {
             return;
         }

package/plugins/message-composer.d.ts

@@ -1,7 +1,6 @@
 import { ContractInfo, RenderContextBase, RenderContext, RenderOptions } from "wasm-ast-types";
 import { BuilderFileType } from "../builder";
 import { BuilderPluginBase } from "./plugin-base";
-export declare const TYPE = "message-composer";
 export declare class MessageComposerPlugin extends BuilderPluginBase<RenderOptions> {
     initContext(contract: ContractInfo, options?: RenderOptions): RenderContextBase<RenderOptions>;
     doRender(name: string, context: RenderContext): Promise<{

package/plugins/message-composer.js

@@ -23,19 +23,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageComposerPlugin = exports.TYPE = void 0;
+exports.MessageComposerPlugin = void 0;
 const case_1 = require("case");
 const w = __importStar(require("wasm-ast-types"));
 const utils_1 = require("../utils");
 const wasm_ast_types_1 = require("wasm-ast-types");
 const plugin_base_1 = require("./plugin-base");
-exports.TYPE = "message-composer";
 class MessageComposerPlugin extends plugin_base_1.BuilderPluginBase {
     initContext(contract, options) {
-        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder?.builderContext);
     }
     async doRender(name, context) {
-        const { enabled } = this.option.messageComposer;
+        const { enabled } = this.options.messageComposer;
         if (!enabled) {
             return;
         }
@@ -63,7 +62,7 @@ class MessageComposerPlugin extends plugin_base_1.BuilderPluginBase {
         }
         return [
             {
-                type: exports.TYPE,
+                type: "message-composer",
                 localname,
                 body,
             },

package/plugins/plugin-base.d.ts

@@ -10,6 +10,11 @@ export interface IBuilderPlugin {
     utils: UtilMapping;
     builder?: TSBuilder;
     setBuilder(builder: TSBuilder): void;
+    /**
+     * prop to indicate to execute the render function in the lifecycle of main process or after
+     */
+    readonly lifecycle: "main" | "after";
+    defaultContractName?: string;
     /**
      * render generated cdoe.
      * @param name the name of contract
@@ -17,7 +22,7 @@ export interface IBuilderPlugin {
      * @param outPath the path of generated code.
      * @returns info of generated files.
      */
-    render(name: string, contractInfo: ContractInfo, outPath: string): Promise<BuilderFile[]>;
+    render(outPath: string, name?: string, contractInfo?: ContractInfo): Promise<BuilderFile[]>;
 }
 /**
  * BuilderPluginBase enable ts-codegen users implement their own plugins by only implement a few functions.
@@ -26,11 +31,16 @@ export declare abstract class BuilderPluginBase<TOpt extends {
     enabled?: boolean;
 }> implements IBuilderPlugin {
     builder?: TSBuilder;
-    option: TOpt;
+    options: TOpt;
     utils: UtilMapping;
-    constructor(opt: TOpt, builder?: TSBuilder);
+    /**
+     * prop to indicate to execute the render function in the lifecycle of main process or after
+     */
+    lifecycle: "main" | "after";
+    defaultContractName?: string;
+    constructor(opts?: TOpt, builder?: TSBuilder);
     setBuilder(builder: TSBuilder): void;
-    render(name: string, contractInfo: ContractInfo, outPath: string): Promise<BuilderFile[]>;
+    render(outPath: string, name?: string, contractInfo?: ContractInfo): Promise<BuilderFile[]>;
     /**
      * init context here
      * @param contract
@@ -48,4 +58,8 @@ export declare abstract class BuilderPluginBase<TOpt extends {
         localname: string;
         body: any[];
     }[]>;
+    /**
+     * get default options
+     */
+    getDefaultOptions(opts: TOpt): any;
 }

package/plugins/plugin-base.js

@@ -31,28 +31,39 @@ const mkdirp_1 = require("mkdirp");
 const path_1 = require("path");
 const fs_1 = require("fs");
 const header_1 = require("../utils/header");
+const wasm_ast_types_1 = require("wasm-ast-types");
 const generator_1 = __importDefault(require("@babel/generator"));
 const t = __importStar(require("@babel/types"));
+const deepmerge_1 = __importDefault(require("deepmerge"));
 /**
  * BuilderPluginBase enable ts-codegen users implement their own plugins by only implement a few functions.
  */
 class BuilderPluginBase {
     builder;
-    option;
+    options;
     utils;
-    constructor(opt, builder) {
-        this.option = opt;
+    /**
+     * prop to indicate to execute the render function in the lifecycle of main process or after
+     */
+    lifecycle;
+    defaultContractName;
+    constructor(opts, builder) {
+        this.options = opts;
         this.builder = builder;
+        this.lifecycle = "main";
     }
     setBuilder(builder) {
         this.builder = builder;
     }
-    async render(name, contractInfo, outPath) {
-        const { enabled } = this.option;
+    async render(outPath, name, contractInfo) {
+        if (!this.options) {
+            this.options = this.getDefaultOptions(this.options);
+        }
+        const { enabled } = this.options;
         if (!enabled) {
             return;
         }
-        const context = this.initContext(contractInfo, this.option);
+        const context = this.initContext(contractInfo, this.options);
         const results = await this.doRender(name, context);
         if (!results || !results.length) {
             return [];
@@ -73,5 +84,11 @@ class BuilderPluginBase {
             };
         });
     }
+    /**
+     * get default options
+     */
+    getDefaultOptions(opts) {
+        return (0, deepmerge_1.default)(wasm_ast_types_1.defaultOptions, opts ?? {});
+    }
 }
 exports.BuilderPluginBase = BuilderPluginBase;

package/plugins/provider-bundle.d.ts

@@ -2,7 +2,7 @@ import { ContractInfo, RenderContextBase, RenderContext } from "wasm-ast-types";
 import { BuilderFileType, TSBuilderOptions } from "../builder";
 import { BuilderPluginBase } from "./plugin-base";
 export declare class ContractsProviderBundlePlugin extends BuilderPluginBase<TSBuilderOptions> {
-    constructor(opt: TSBuilderOptions);
+    constructor(opt?: TSBuilderOptions);
     initContext(contract: ContractInfo, options?: TSBuilderOptions): RenderContextBase<TSBuilderOptions>;
     doRender(name: string, context: RenderContext): Promise<{
         type: BuilderFileType;

package/plugins/provider-bundle.js

@@ -32,6 +32,8 @@ const provider_1 = require("./provider");
 class ContractsProviderBundlePlugin extends plugin_base_1.BuilderPluginBase {
     constructor(opt) {
         super(opt);
+        this.lifecycle = "after";
+        this.defaultContractName = "contractContextProviders";
         this.utils = {
             CosmWasmClient: "@cosmjs/cosmwasm-stargate",
             SigningCosmWasmClient: "@cosmjs/cosmwasm-stargate",
@@ -41,10 +43,10 @@ class ContractsProviderBundlePlugin extends plugin_base_1.BuilderPluginBase {
         };
     }
     initContext(contract, options) {
-        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder?.builderContext);
     }
     async doRender(name, context) {
-        if (!this.option?.useContractsHook?.enabled) {
+        if (!this.options?.useContractsHook?.enabled) {
             return;
         }
         const providerInfos = context.getProviderInfos();

package/plugins/provider.js

@@ -42,10 +42,10 @@ class ContractsContextProviderPlugin extends plugin_base_1.BuilderPluginBase {
         };
     }
     initContext(contract, options) {
-        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder?.builderContext);
     }
     async doRender(name, context) {
-        if (!this.option?.useContractsHook?.enabled) {
+        if (!this.options?.useContractsHook?.enabled) {
             return;
         }
         const providerInfo = context.getProviderInfos()[name];

package/plugins/react-query.js

@@ -31,10 +31,10 @@ const wasm_ast_types_1 = require("wasm-ast-types");
 const plugin_base_1 = require("./plugin-base");
 class ReactQueryPlugin extends plugin_base_1.BuilderPluginBase {
     initContext(contract, options) {
-        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder?.builderContext);
     }
     async doRender(name, context) {
-        const options = this.option.reactQuery;
+        const options = this.options.reactQuery;
         const { enabled } = options;
         if (!enabled) {
             return;

package/plugins/recoil.js

@@ -34,10 +34,10 @@ class RecoilPlugin extends plugin_base_1.BuilderPluginBase {
         selectorFamily: 'recoil',
     };
     initContext(contract, options) {
-        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder?.builderContext);
     }
     async doRender(name, context) {
-        const { enabled } = this.option.recoil;
+        const { enabled } = this.options.recoil;
         if (!enabled) {
             return;
         }

package/plugins/types.js

@@ -32,15 +32,15 @@ const wasm_ast_types_1 = require("wasm-ast-types");
 const plugin_base_1 = require("./plugin-base");
 class TypesPlugin extends plugin_base_1.BuilderPluginBase {
     initContext(contract, options) {
-        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder?.builderContext);
     }
     async doRender(name, context) {
-        const { enabled } = this.option.types;
+        const { enabled } = this.options.types;
         if (!enabled) {
             return;
         }
         const { schemas } = context.contract;
-        const options = this.option.types;
+        const options = this.options.types;
         const localname = (0, case_1.pascal)(name) + '.types.ts';
         const ExecuteMsg = (0, utils_1.findExecuteMsg)(schemas);
         const typeHash = await (0, utils_1.findAndParseTypes)(schemas);

package/utils/contracts.d.ts

@@ -0,0 +1,2 @@
+import { ContractInfo } from "wasm-ast-types";
+export declare const createDefaultContractInfo: () => ContractInfo;

package/utils/contracts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultContractInfo = void 0;
+const createDefaultContractInfo = () => {
+    return {
+        schemas: [],
+    };
+};
+exports.createDefaultContractInfo = createDefaultContractInfo;

package/esm/generators/client.js

@@ -1,67 +0,0 @@
-import { pascal } from "case";
-import { header } from '../utils/header';
-import { join } from "path";
-import { sync as mkdirp } from "mkdirp";
-import * as w from 'wasm-ast-types';
-import * as t from '@babel/types';
-import { writeFileSync } from 'fs';
-import generate from "@babel/generator";
-import { getMessageProperties } from "wasm-ast-types";
-import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
-import { RenderContext } from "wasm-ast-types";
-export default async (name, contractInfo, outPath, tsClientOptions) => {
-    const { schemas } = contractInfo;
-    const context = new RenderContext(contractInfo, {
-        client: tsClientOptions ?? {}
-    });
-    // const options = context.options.client;
-    const localname = pascal(name) + '.client.ts';
-    const TypesFile = pascal(name) + '.types';
-    const QueryMsg = findQueryMsg(schemas);
-    const ExecuteMsg = findExecuteMsg(schemas);
-    const typeHash = await findAndParseTypes(schemas);
-    let Client = null;
-    let Instance = null;
-    let QueryClient = null;
-    let ReadOnlyInstance = null;
-    const body = [];
-    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
-    // query messages
-    if (QueryMsg) {
-        QueryClient = pascal(`${name}QueryClient`);
-        ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
-        body.push(w.createQueryInterface(context, ReadOnlyInstance, QueryMsg));
-        body.push(w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg));
-    }
-    // execute messages
-    if (ExecuteMsg) {
-        const children = getMessageProperties(ExecuteMsg);
-        if (children.length > 0) {
-            Client = pascal(`${name}Client`);
-            Instance = pascal(`${name}Interface`);
-            body.push(w.createExecuteInterface(context, Instance, context.options.client.execExtendsQuery ? ReadOnlyInstance : null, ExecuteMsg));
-            body.push(w.createExecuteClass(context, Client, Instance, context.options.client.execExtendsQuery ? QueryClient : null, ExecuteMsg));
-        }
-    }
-    if (typeHash.hasOwnProperty('Coin')) {
-        // @ts-ignore
-        delete context.utils.Coin;
-    }
-    const imports = context.getImports();
-    const code = header + generate(
-    // @ts-ignore
-    t.program([
-        ...imports,
-        ...body
-    ])).code;
-    mkdirp(outPath);
-    writeFileSync(join(outPath, localname), code);
-    return [
-        {
-            type: 'client',
-            contract: name,
-            localname,
-            filename: join(outPath, localname),
-        }
-    ];
-};

package/esm/generators/message-builder.js

@@ -1,58 +0,0 @@
-import { pascal } from "case";
-import { header } from "../utils/header";
-import { join } from "path";
-import { sync as mkdirp } from "mkdirp";
-import * as w from "wasm-ast-types";
-import * as t from "@babel/types";
-import { writeFileSync } from "fs";
-import generate from "@babel/generator";
-import { getMessageProperties } from "wasm-ast-types";
-import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
-import { RenderContext } from 'wasm-ast-types';
-export default async (name, contractInfo, outPath, messageBuilderOptions) => {
-    const { schemas } = contractInfo;
-    const context = new RenderContext(contractInfo, {
-        messageBuilder: messageBuilderOptions ?? {},
-    });
-    const localname = pascal(name) + ".message-builder.ts";
-    const TypesFile = pascal(name) + ".types";
-    const ExecuteMsg = findExecuteMsg(schemas);
-    const typeHash = await findAndParseTypes(schemas);
-    const body = [];
-    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
-    body.push(w.importStmt(["CamelCasedProperties"], "type-fest"));
-    // execute messages
-    if (ExecuteMsg) {
-        const children = getMessageProperties(ExecuteMsg);
-        if (children.length > 0) {
-            const className = pascal(`${name}ExecuteMsgBuilder`);
-            body.push(w.createMessageBuilderClass(context, className, ExecuteMsg));
-        }
-    }
-    const QueryMsg = findQueryMsg(schemas);
-    // query messages
-    if (QueryMsg) {
-        const children = getMessageProperties(QueryMsg);
-        if (children.length > 0) {
-            const className = pascal(`${name}QueryMsgBuilder`);
-            body.push(w.createMessageBuilderClass(context, className, QueryMsg));
-        }
-    }
-    if (typeHash.hasOwnProperty("Coin")) {
-        // @ts-ignore
-        delete context.utils.Coin;
-    }
-    const imports = context.getImports();
-    // @ts-ignore
-    const code = header + generate(t.program([...imports, ...body])).code;
-    mkdirp(outPath);
-    writeFileSync(join(outPath, localname), code);
-    return [
-        {
-            type: "message-builder",
-            contract: name,
-            localname,
-            filename: join(outPath, localname),
-        },
-    ];
-};

package/esm/generators/message-composer.js

@@ -1,55 +0,0 @@
-import { pascal } from "case";
-import { header } from '../utils/header';
-import { join } from "path";
-import { sync as mkdirp } from "mkdirp";
-import * as w from 'wasm-ast-types';
-import * as t from '@babel/types';
-import { writeFileSync } from 'fs';
-import generate from "@babel/generator";
-import { getMessageProperties } from "wasm-ast-types";
-import { findAndParseTypes, findExecuteMsg } from "../utils";
-import { RenderContext } from "wasm-ast-types";
-export default async (name, contractInfo, outPath, messageComposerOptions) => {
-    const { schemas } = contractInfo;
-    const context = new RenderContext(contractInfo, {
-        messageComposer: messageComposerOptions ?? {}
-    });
-    // const options = context.options.messageComposer;
-    const localname = pascal(name) + '.message-composer.ts';
-    const TypesFile = pascal(name) + '.types';
-    const ExecuteMsg = findExecuteMsg(schemas);
-    const typeHash = await findAndParseTypes(schemas);
-    const body = [];
-    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
-    // execute messages
-    if (ExecuteMsg) {
-        const children = getMessageProperties(ExecuteMsg);
-        if (children.length > 0) {
-            const TheClass = pascal(`${name}MessageComposer`);
-            const Interface = pascal(`${name}Message`);
-            body.push(w.createMessageComposerInterface(context, Interface, ExecuteMsg));
-            body.push(w.createMessageComposerClass(context, TheClass, Interface, ExecuteMsg));
-        }
-    }
-    if (typeHash.hasOwnProperty('Coin')) {
-        // @ts-ignore
-        delete context.utils.Coin;
-    }
-    const imports = context.getImports();
-    const code = header + generate(
-    // @ts-ignore
-    t.program([
-        ...imports,
-        ...body
-    ])).code;
-    mkdirp(outPath);
-    writeFileSync(join(outPath, localname), code);
-    return [
-        {
-            type: 'message-composer',
-            contract: name,
-            localname,
-            filename: join(outPath, localname),
-        }
-    ];
-};

package/esm/generators/react-query.js

@@ -1,76 +0,0 @@
-import { pascal } from "case";
-import { header } from '../utils/header';
-import { join } from "path";
-import { sync as mkdirp } from "mkdirp";
-import * as w from 'wasm-ast-types';
-import { RenderContext } from 'wasm-ast-types';
-import * as t from '@babel/types';
-import { writeFileSync } from 'fs';
-import generate from "@babel/generator";
-import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
-import { getMessageProperties } from "wasm-ast-types";
-export default async (contractName, contractInfo, outPath, reactQueryOptions) => {
-    const { schemas } = contractInfo;
-    const context = new RenderContext(contractInfo, {
-        reactQuery: reactQueryOptions ?? {}
-    });
-    const options = context.options.reactQuery;
-    const localname = pascal(`${contractName}`) + '.react-query.ts';
-    const ContractFile = pascal(`${contractName}`) + '.client';
-    const TypesFile = pascal(`${contractName}`) + '.types';
-    const QueryMsg = findQueryMsg(schemas);
-    const ExecuteMsg = findExecuteMsg(schemas);
-    const typeHash = await findAndParseTypes(schemas);
-    const ExecuteClient = pascal(`${contractName}Client`);
-    const QueryClient = pascal(`${contractName}QueryClient`);
-    const body = [];
-    const clientImports = [];
-    QueryMsg && clientImports.push(QueryClient);
-    // check that there are commands within the exec msg
-    const shouldGenerateMutationHooks = ExecuteMsg && options?.version === 'v4' && options?.mutations && getMessageProperties(ExecuteMsg).length > 0;
-    if (shouldGenerateMutationHooks) {
-        clientImports.push(ExecuteClient);
-    }
-    // general contract imports
-    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
-    // client imports
-    body.push(w.importStmt(clientImports, `./${ContractFile}`));
-    // query messages
-    if (QueryMsg) {
-        [].push.apply(body, w.createReactQueryHooks({
-            context,
-            queryMsg: QueryMsg,
-            contractName: contractName,
-            QueryClient
-        }));
-    }
-    if (shouldGenerateMutationHooks) {
-        [].push.apply(body, w.createReactQueryMutationHooks({
-            context,
-            execMsg: ExecuteMsg,
-            contractName: contractName,
-            ExecuteClient
-        }));
-    }
-    if (typeHash.hasOwnProperty('Coin')) {
-        // @ts-ignore
-        delete context.utils.Coin;
-    }
-    const imports = context.getImports();
-    const code = header + generate(
-    // @ts-ignore
-    t.program([
-        ...imports,
-        ...body
-    ])).code;
-    mkdirp(outPath);
-    writeFileSync(join(outPath, localname), code);
-    return [
-        {
-            type: 'react-query',
-            contract: contractName,
-            localname,
-            filename: join(outPath, localname),
-        }
-    ];
-};

package/esm/generators/recoil.js

@@ -1,58 +0,0 @@
-import { pascal } from "case";
-import { header } from '../utils/header';
-import { join } from "path";
-import { sync as mkdirp } from "mkdirp";
-import * as w from 'wasm-ast-types';
-import * as t from '@babel/types';
-import { writeFileSync } from 'fs';
-import generate from "@babel/generator";
-import { findAndParseTypes, findQueryMsg } from "../utils";
-import { RenderContext } from "wasm-ast-types";
-export default async (name, contractInfo, outPath, recoilOptions) => {
-    const { schemas } = contractInfo;
-    const context = new RenderContext(contractInfo, {
-        recoil: recoilOptions ?? {}
-    });
-    const options = context.options.recoil;
-    const localname = pascal(name) + '.recoil.ts';
-    const ContractFile = pascal(name) + '.client';
-    const TypesFile = pascal(name) + '.types';
-    const QueryMsg = findQueryMsg(schemas);
-    const typeHash = await findAndParseTypes(schemas);
-    let QueryClient = null;
-    let ReadOnlyInstance = null;
-    const body = [];
-    body.push(w.importStmt(['cosmWasmClient'], './chain'));
-    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
-    // query messages
-    if (QueryMsg) {
-        QueryClient = pascal(`${name}QueryClient`);
-        ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
-        body.push(w.importStmt([QueryClient], `./${ContractFile}`));
-        body.push(w.createRecoilQueryClientType());
-        body.push(w.createRecoilQueryClient(context, name, QueryClient));
-        const selectors = w.createRecoilSelectors(context, name, QueryClient, QueryMsg);
-        body.push(...selectors);
-    }
-    if (typeHash.hasOwnProperty('Coin')) {
-        // @ts-ignore
-        delete context.utils.Coin;
-    }
-    const imports = context.getImports();
-    const code = header + generate(
-    // @ts-ignore
-    t.program([
-        ...imports,
-        ...body
-    ])).code;
-    mkdirp(outPath);
-    writeFileSync(join(outPath, localname), code);
-    return [
-        {
-            type: 'recoil',
-            contract: name,
-            localname,
-            filename: join(outPath, localname),
-        }
-    ];
-};