@cosmwasm/ts-codegen 0.35.7 → 1.1.0

package/plugins/message-builder.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBuilderPlugin = 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");
+class MessageBuilderPlugin extends plugin_base_1.BuilderPluginBase {
+    initContext(contract, options) {
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+    }
+    async doRender(name, context) {
+        const { enabled } = this.option.messageBuilder;
+        if (!enabled) {
+            return;
+        }
+        const { schemas } = context.contract;
+        const localname = (0, case_1.pascal)(name) + '.message-builder.ts';
+        const TypesFile = (0, case_1.pascal)(name) + '.types';
+        const ExecuteMsg = (0, utils_1.findExecuteMsg)(schemas);
+        const typeHash = await (0, utils_1.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 = (0, wasm_ast_types_1.getMessageProperties)(ExecuteMsg);
+            if (children.length > 0) {
+                const className = (0, case_1.pascal)(`${name}ExecuteMsgBuilder`);
+                body.push(w.createMessageBuilderClass(context, className, ExecuteMsg));
+            }
+        }
+        const QueryMsg = (0, utils_1.findQueryMsg)(schemas);
+        // query messages
+        if (QueryMsg) {
+            const children = (0, wasm_ast_types_1.getMessageProperties)(QueryMsg);
+            if (children.length > 0) {
+                const className = (0, case_1.pascal)(`${name}QueryMsgBuilder`);
+                body.push(w.createMessageBuilderClass(context, className, QueryMsg));
+            }
+        }
+        if (typeHash.hasOwnProperty('Coin')) {
+            // @ts-ignore
+            delete context.utils.Coin;
+        }
+        return [
+            {
+                type: 'message-builder',
+                localname,
+                body
+            }
+        ];
+    }
+}
+exports.MessageBuilderPlugin = MessageBuilderPlugin;

package/plugins/message-composer.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageComposerPlugin = exports.TYPE = 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);
+    }
+    async doRender(name, context) {
+        const { enabled } = this.option.messageComposer;
+        if (!enabled) {
+            return;
+        }
+        const { schemas } = context.contract;
+        const localname = (0, case_1.pascal)(name) + ".message-composer.ts";
+        const TypesFile = (0, case_1.pascal)(name) + ".types";
+        const ExecuteMsg = (0, utils_1.findExecuteMsg)(schemas);
+        const typeHash = await (0, utils_1.findAndParseTypes)(schemas);
+        const body = [];
+        body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+        // execute messages
+        if (ExecuteMsg) {
+            const children = (0, wasm_ast_types_1.getMessageProperties)(ExecuteMsg);
+            if (children.length > 0) {
+                const TheClass = (0, case_1.pascal)(`${name}MsgComposer`);
+                const Interface = (0, case_1.pascal)(`${name}Msg`);
+                body.push(w.createMessageComposerInterface(context, Interface, ExecuteMsg));
+                body.push(w.createMessageComposerClass(context, TheClass, Interface, ExecuteMsg));
+                context.addProviderInfo(name, w.PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE, TheClass, localname);
+            }
+        }
+        if (typeHash.hasOwnProperty("Coin")) {
+            // @ts-ignore
+            delete context.utils.Coin;
+        }
+        return [
+            {
+                type: exports.TYPE,
+                localname,
+                body,
+            },
+        ];
+    }
+}
+exports.MessageComposerPlugin = MessageComposerPlugin;

package/{types/src/plugins → plugins}/plugin-base.d.ts

@@ -9,7 +9,7 @@ export interface IBuilderPlugin {
      */
     utils: UtilMapping;
     builder?: TSBuilder;
-    setBuilder(builder: TSBuilder): any;
+    setBuilder(builder: TSBuilder): void;
     /**
      * render generated cdoe.
      * @param name the name of contract

package/plugins/plugin-base.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuilderPluginBase = void 0;
+const mkdirp_1 = require("mkdirp");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const header_1 = require("../utils/header");
+const generator_1 = __importDefault(require("@babel/generator"));
+const t = __importStar(require("@babel/types"));
+/**
+ * BuilderPluginBase enable ts-codegen users implement their own plugins by only implement a few functions.
+ */
+class BuilderPluginBase {
+    builder;
+    option;
+    utils;
+    constructor(opt, builder) {
+        this.option = opt;
+        this.builder = builder;
+    }
+    setBuilder(builder) {
+        this.builder = builder;
+    }
+    async render(name, contractInfo, outPath) {
+        const { enabled } = this.option;
+        if (!enabled) {
+            return;
+        }
+        const context = this.initContext(contractInfo, this.option);
+        const results = await this.doRender(name, context);
+        if (!results || !results.length) {
+            return [];
+        }
+        return results.map((result) => {
+            const imports = context.getImports(this.utils, result.localname);
+            // @ts-ignore
+            const code = header_1.header + (0, generator_1.default)(t.program([...imports, ...result.body])).code;
+            (0, mkdirp_1.sync)(outPath);
+            const filename = (0, path_1.join)(outPath, result.localname);
+            (0, fs_1.writeFileSync)(filename, code);
+            return {
+                type: result.type,
+                pluginType: result.pluginType,
+                contract: name,
+                localname: result.localname,
+                filename,
+            };
+        });
+    }
+}
+exports.BuilderPluginBase = BuilderPluginBase;

package/plugins/provider-bundle.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractsProviderBundlePlugin = void 0;
+const case_1 = require("case");
+const w = __importStar(require("wasm-ast-types"));
+const wasm_ast_types_1 = require("wasm-ast-types");
+const plugin_base_1 = require("./plugin-base");
+const provider_1 = require("./provider");
+class ContractsProviderBundlePlugin extends plugin_base_1.BuilderPluginBase {
+    constructor(opt) {
+        super(opt);
+        this.utils = {
+            CosmWasmClient: "@cosmjs/cosmwasm-stargate",
+            SigningCosmWasmClient: "@cosmjs/cosmwasm-stargate",
+            IQueryClientProvider: "__contractContextBase__",
+            ISigningClientProvider: "__contractContextBase__",
+            IMessageComposerProvider: "__contractContextBase__",
+        };
+    }
+    initContext(contract, options) {
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+    }
+    async doRender(name, context) {
+        if (!this.option?.useContractsHooks?.enabled) {
+            return;
+        }
+        const providerInfos = context.getProviderInfos();
+        if (!Object.keys(providerInfos || {})?.length) {
+            return;
+        }
+        const localname = "contractContextProviders.ts";
+        const body = [];
+        context.addUtil("CosmWasmClient");
+        context.addUtil("SigningCosmWasmClient");
+        context.addUtil("IQueryClientProvider");
+        context.addUtil("ISigningClientProvider");
+        context.addUtil("IMessageComposerProvider");
+        for (const name in providerInfos) {
+            if (Object.prototype.hasOwnProperty.call(providerInfos, name)) {
+                const providerInfo = providerInfos[name];
+                for (const key in providerInfo) {
+                    if (Object.prototype.hasOwnProperty.call(providerInfo, key)) {
+                        const info = providerInfo[key];
+                        body.push(w.importStmt([info.classname], `./${info.basename}`));
+                    }
+                }
+                body.push(w.importStmt([(0, case_1.pascal)(name)], `./${(0, provider_1.GetLocalBaseNameByContractName)(name)}`));
+            }
+        }
+        body.push(w.createIContractsContext(providerInfos));
+        body.push(w.createGettingProviders(providerInfos));
+        return [
+            {
+                type: "plugin",
+                pluginType: "contractContextProviders",
+                localname,
+                body,
+            },
+        ];
+    }
+}
+exports.ContractsProviderBundlePlugin = ContractsProviderBundlePlugin;

package/{types/src/plugins → plugins}/provider.d.ts

@@ -1,8 +1,8 @@
 import { ContractInfo, RenderContextBase, RenderContext } from "wasm-ast-types";
 import { BuilderFileType, TSBuilderOptions } from "../builder";
 import { BuilderPluginBase } from "./plugin-base";
-export declare const GetLocalNameByContractName: (name: any) => string;
-export declare const GetLocalBaseNameByContractName: (name: any) => string;
+export declare const GetLocalNameByContractName: (name: string) => string;
+export declare const GetLocalBaseNameByContractName: (name: string) => string;
 export declare class ContractsContextProviderPlugin extends BuilderPluginBase<TSBuilderOptions> {
     constructor(opt: TSBuilderOptions);
     initContext(contract: ContractInfo, options?: TSBuilderOptions): RenderContextBase<TSBuilderOptions>;

package/plugins/provider.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractsContextProviderPlugin = exports.GetLocalBaseNameByContractName = exports.GetLocalNameByContractName = void 0;
+const case_1 = require("case");
+const w = __importStar(require("wasm-ast-types"));
+const wasm_ast_types_1 = require("wasm-ast-types");
+const plugin_base_1 = require("./plugin-base");
+const GetLocalNameByContractName = (name) => `${(0, case_1.pascal)(name)}.provider.ts`;
+exports.GetLocalNameByContractName = GetLocalNameByContractName;
+const GetLocalBaseNameByContractName = (name) => `${(0, case_1.pascal)(name)}.provider`;
+exports.GetLocalBaseNameByContractName = GetLocalBaseNameByContractName;
+class ContractsContextProviderPlugin extends plugin_base_1.BuilderPluginBase {
+    constructor(opt) {
+        super(opt);
+        this.utils = {
+            ContractBase: "__contractContextBase__",
+            IContractConstructor: "__contractContextBase__",
+            IEmptyClient: "__contractContextBase__",
+        };
+    }
+    initContext(contract, options) {
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+    }
+    async doRender(name, context) {
+        if (!this.option?.useContractsHooks?.enabled) {
+            return;
+        }
+        const providerInfo = context.getProviderInfos()[name];
+        if (!Object.keys(providerInfo || {})?.length) {
+            return;
+        }
+        context.addUtil("ContractBase");
+        context.addUtil("IContractConstructor");
+        const localname = (0, exports.GetLocalNameByContractName)(name);
+        let needEmptyClientType = false;
+        let clientFile = null;
+        let clientClasses = [];
+        const body = [];
+        const signClientProviderInfo = providerInfo[w.PROVIDER_TYPES.SIGNING_CLIENT_TYPE];
+        if (signClientProviderInfo) {
+            clientFile = `./${signClientProviderInfo.basename}`;
+            clientClasses.push(signClientProviderInfo.classname);
+        }
+        else {
+            needEmptyClientType = true;
+        }
+        const queryClientProviderInfo = providerInfo[w.PROVIDER_TYPES.QUERY_CLIENT_TYPE];
+        if (queryClientProviderInfo) {
+            clientFile = `./${queryClientProviderInfo.basename}`;
+            clientClasses.push(queryClientProviderInfo.classname);
+        }
+        else {
+            needEmptyClientType = true;
+        }
+        if (clientFile) {
+            body.push(w.importStmt(clientClasses, clientFile));
+        }
+        const messageComposerProviderInfo = providerInfo[w.PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE];
+        if (messageComposerProviderInfo) {
+            body.push(w.importStmt([messageComposerProviderInfo.classname], `./${messageComposerProviderInfo.basename}`));
+        }
+        else {
+            needEmptyClientType = true;
+        }
+        if (needEmptyClientType) {
+            context.addUtil("IEmptyClient");
+        }
+        body.push(w.createProvider(name, providerInfo));
+        return [
+            {
+                type: "plugin",
+                pluginType: "provider",
+                localname,
+                body,
+            },
+        ];
+    }
+}
+exports.ContractsContextProviderPlugin = ContractsContextProviderPlugin;

package/plugins/react-query.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactQueryPlugin = 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");
+class ReactQueryPlugin extends plugin_base_1.BuilderPluginBase {
+    initContext(contract, options) {
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+    }
+    async doRender(name, context) {
+        const options = this.option.reactQuery;
+        const { enabled } = options;
+        if (!enabled) {
+            return;
+        }
+        const { schemas } = context.contract;
+        const localname = (0, case_1.pascal)(`${name}`) + '.react-query.ts';
+        const ContractFile = (0, case_1.pascal)(`${name}`) + '.client';
+        const TypesFile = (0, case_1.pascal)(`${name}`) + '.types';
+        const QueryMsg = (0, utils_1.findQueryMsg)(schemas);
+        const ExecuteMsg = (0, utils_1.findExecuteMsg)(schemas);
+        const typeHash = await (0, utils_1.findAndParseTypes)(schemas);
+        const ExecuteClient = (0, case_1.pascal)(`${name}Client`);
+        const QueryClient = (0, case_1.pascal)(`${name}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 &&
+            (0, wasm_ast_types_1.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: name,
+                QueryClient
+            }));
+        }
+        if (shouldGenerateMutationHooks) {
+            [].push.apply(body, w.createReactQueryMutationHooks({
+                context,
+                execMsg: ExecuteMsg,
+                contractName: name,
+                ExecuteClient
+            }));
+        }
+        if (typeHash.hasOwnProperty('Coin')) {
+            // @ts-ignore
+            delete context.utils.Coin;
+        }
+        return [
+            {
+                type: 'react-query',
+                localname,
+                body
+            }
+        ];
+    }
+}
+exports.ReactQueryPlugin = ReactQueryPlugin;

package/plugins/recoil.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecoilPlugin = 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");
+class RecoilPlugin extends plugin_base_1.BuilderPluginBase {
+    utils = {
+        selectorFamily: 'recoil',
+    };
+    initContext(contract, options) {
+        return new wasm_ast_types_1.RenderContext(contract, options, this.builder.builderContext);
+    }
+    async doRender(name, context) {
+        const { enabled } = this.option.recoil;
+        if (!enabled) {
+            return;
+        }
+        const { schemas } = context.contract;
+        const localname = (0, case_1.pascal)(name) + '.recoil.ts';
+        const ContractFile = (0, case_1.pascal)(name) + '.client';
+        const TypesFile = (0, case_1.pascal)(name) + '.types';
+        const QueryMsg = (0, utils_1.findQueryMsg)(schemas);
+        const typeHash = await (0, utils_1.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 = (0, case_1.pascal)(`${name}QueryClient`);
+            ReadOnlyInstance = (0, case_1.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;
+        }
+        return [
+            {
+                type: 'recoil',
+                localname,
+                body
+            }
+        ];
+    }
+}
+exports.RecoilPlugin = RecoilPlugin;

package/plugins/types.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypesPlugin = void 0;
+const t = __importStar(require("@babel/types"));
+const clean_1 = require("../utils/clean");
+const case_1 = require("case");
+const utils_1 = require("../utils");
+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);
+    }
+    async doRender(name, context) {
+        const { enabled } = this.option.types;
+        if (!enabled) {
+            return;
+        }
+        const { schemas } = context.contract;
+        const options = this.option.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);
+        const body = [];
+        // TYPES
+        Object.values(typeHash).forEach((type) => {
+            body.push((0, clean_1.clean)(type));
+        });
+        // alias the ExecuteMsg
+        if (options.aliasExecuteMsg && ExecuteMsg) {
+            body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+        }
+        return [
+            {
+                type: 'type',
+                localname,
+                body
+            }
+        ];
+    }
+}
+exports.TypesPlugin = TypesPlugin;