@cosmwasm/ts-codegen 0.35.6 → 1.0.0

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;

package/ts-codegen.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+var argv = require('minimist')(process.argv.slice(2));
+(async () => {
+    await (0, cli_1.cli)(argv);
+})();

package/utils/clean.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clean = void 0;
+const clean = (obj) => {
+    var copy;
+    // Handle the 3 simple types, and null or undefined
+    if (null == obj || 'object' != typeof obj)
+        return obj;
+    // Handle Date
+    if (obj instanceof Date) {
+        copy = new Date();
+        copy.setTime(obj.getTime());
+        return copy;
+    }
+    // Handle Array
+    if (obj instanceof Array) {
+        copy = [];
+        for (var i = 0, len = obj.length; i < len; i++) {
+            copy[i] = (0, exports.clean)(obj[i]);
+        }
+        return copy;
+    }
+    // Handle Object
+    if (obj instanceof Object || typeof obj === 'object') {
+        copy = {};
+        for (var attr in obj) {
+            if (obj.hasOwnProperty(attr)) {
+                switch (attr) {
+                    case 'leadingComments':
+                    case 'trailingComments':
+                    case 'loc':
+                    case 'start':
+                    case 'end':
+                        break;
+                    default:
+                        // @ts-ignore
+                        copy[attr] = (0, exports.clean)(obj[attr]);
+                }
+            }
+            else {
+                // @ts-ignore
+                copy[attr] = (0, exports.clean)(obj[attr]);
+            }
+        }
+        return copy;
+    }
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+};
+exports.clean = clean;

package/utils/cleanse.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanse = void 0;
+const case_1 = require("case");
+const cleanFor = (str) => {
+    /*
+        1. look at first char after _for_
+        2. ONLY if you find capitals after, modify it
+    */
+    while (/_[a-z]+_[A-Z]/.test(str)) {
+        const m = str.match(/(_[a-z]+_)[A-Z]/);
+        str = str.replace(m[1], (0, case_1.pascal)(m[1]));
+    }
+    return str;
+};
+const cleanNullable = (str) => {
+    if (/^Nullable_/.test(str)) {
+        str = str.replace(/^Nullable_/, 'Nullable');
+    }
+    return str;
+};
+const cleanse = (obj) => {
+    var copy;
+    // Handle the 3 simple types, and null or undefined
+    if (null == obj || 'object' != typeof obj)
+        return obj;
+    // Handle Date
+    if (obj instanceof Date) {
+        copy = new Date();
+        copy.setTime(obj.getTime());
+        return copy;
+    }
+    // Handle Array
+    if (obj instanceof Array) {
+        copy = [];
+        for (var i = 0, len = obj.length; i < len; i++) {
+            copy[i] = (0, exports.cleanse)(obj[i]);
+        }
+        return copy;
+    }
+    // Handle Object
+    if (obj instanceof Object || typeof obj === 'object') {
+        copy = {};
+        // https://github.com/CosmWasm/cosmwasm-typescript-gen/issues/27
+        if (Array.isArray(obj.enum) && obj.enum.length === 0) {
+            delete obj.enum;
+            if (!obj.type) {
+                obj.type = 'string';
+            }
+        }
+        for (var attr in obj) {
+            if (obj.hasOwnProperty(attr)) {
+                if (/_for_/.test(attr)) {
+                    // @ts-ignore
+                    copy[cleanFor(attr)] = (0, exports.cleanse)(obj[attr]);
+                }
+                else if (/^Nullable_/.test(attr)) {
+                    // @ts-ignore
+                    copy[cleanNullable(attr)] = (0, exports.cleanse)(obj[attr]);
+                }
+                else {
+                    switch (attr) {
+                        case 'title':
+                        case '$ref':
+                            if (typeof obj[attr] === 'string') {
+                                // @ts-ignore
+                                copy[attr] = (0, exports.cleanse)(cleanNullable(cleanFor(obj[attr])));
+                            }
+                            else {
+                                // @ts-ignore
+                                copy[attr] = (0, exports.cleanse)(obj[attr]);
+                            }
+                            break;
+                        default:
+                            // @ts-ignore
+                            copy[attr] = (0, exports.cleanse)(obj[attr]);
+                    }
+                }
+            }
+            else {
+                // @ts-ignore
+                copy[attr] = (0, exports.cleanse)(obj[attr]);
+            }
+        }
+        return copy;
+    }
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+};
+exports.cleanse = cleanse;