wasm-ast-types 0.26.4 → 1.1.0

package/{types/utils → utils}/babel.d.ts

@@ -1,25 +1,26 @@
 import * as t from '@babel/types';
-import { Field } from '../types';
+import { Field } from '@cosmology/ts-codegen-types';
 import { TSTypeAnnotation, TSExpressionWithTypeArguments } from '@babel/types';
+import { JSONSchema } from '@cosmology/ts-codegen-types';
 export declare const propertySignature: (name: string, typeAnnotation: TSTypeAnnotation, optional?: boolean) => t.TSPropertySignature;
 export declare const identifier: (name: string, typeAnnotation: t.TSTypeAnnotation, optional?: boolean) => t.Identifier;
 export declare const tsTypeOperator: (typeAnnotation: t.TSType, operator: string) => t.TSTypeOperator;
-export declare const getMessageProperties: (msg: any) => any[];
+export declare const getMessageProperties: (msg: JSONSchema) => JSONSchema[];
 export declare const tsPropertySignature: (key: t.Expression, typeAnnotation: t.TSTypeAnnotation, optional: boolean) => t.TSPropertySignature;
 export declare const tsObjectPattern: (properties: (t.RestElement | t.ObjectProperty)[], typeAnnotation: t.TSTypeAnnotation) => t.ObjectPattern;
 export declare const callExpression: (callee: t.Expression | t.V8IntrinsicIdentifier, _arguments: (t.Expression | t.SpreadElement | t.ArgumentPlaceholder)[], typeParameters: t.TSTypeParameterInstantiation) => t.CallExpression;
 export declare const bindMethod: (name: string) => t.ExpressionStatement;
 export declare const typedIdentifier: (name: string, typeAnnotation: TSTypeAnnotation, optional?: boolean) => t.Identifier;
-export declare const promiseTypeAnnotation: (name: any) => t.TSTypeAnnotation;
+export declare const promiseTypeAnnotation: (name: string) => t.TSTypeAnnotation;
 export declare const abstractClassDeclaration: (name: string, body: any[], implementsExressions?: TSExpressionWithTypeArguments[], superClass?: t.Identifier) => t.ClassDeclaration;
 export declare const classDeclaration: (name: string, body: any[], implementsExressions?: TSExpressionWithTypeArguments[], superClass?: t.Identifier) => t.ClassDeclaration;
 export declare const classProperty: (name: string, typeAnnotation?: TSTypeAnnotation, isReadonly?: boolean, isStatic?: boolean, noImplicitOverride?: boolean) => t.ClassProperty;
 export declare const arrowFunctionExpression: (params: (t.Identifier | t.Pattern | t.RestElement)[], body: t.BlockStatement, returnType: t.TSTypeAnnotation, isAsync?: boolean) => t.ArrowFunctionExpression;
-export declare const recursiveNamespace: (names: any, moduleBlockBody: any) => any;
-export declare const arrayTypeNDimensions: (body: any, n: any) => any;
+export declare const recursiveNamespace: (names: string[], moduleBlockBody: any) => t.ExportNamedDeclaration[];
+export declare const arrayTypeNDimensions: (body: any, n: number) => t.TSArrayType;
 export declare const FieldTypeAsts: {
     string: () => t.TSStringKeyword;
-    array: (type: any) => t.TSArrayType;
+    array: (type: 'string' | 'Duration' | 'Height' | 'Coin' | 'Long') => t.TSArrayType;
     Duration: () => t.TSTypeReference;
     Height: () => t.TSTypeReference;
     Coin: () => t.TSTypeReference;
@@ -34,8 +35,8 @@ export declare const getFieldDimensionality: (field: Field) => {
     dimensions: number;
     isArray: boolean;
 };
-export declare const memberExpressionOrIdentifier: (names: any) => any;
-export declare const memberExpressionOrIdentifierSnake: (names: any) => any;
+export declare const memberExpressionOrIdentifier: (names: string[]) => t.MemberExpression | t.Identifier;
+export declare const memberExpressionOrIdentifierSnake: (names: string[]) => t.MemberExpression | t.Identifier;
 /**
  * If optional, return a conditional, otherwise just the expression
  */

package/utils/babel.js

@@ -0,0 +1,285 @@
+"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.pickTypeReference = exports.omitTypeReference = exports.parameterizedTypeReference = exports.typeRefOrUnionWithUndefined = exports.optionalConditionalExpression = exports.memberExpressionOrIdentifierSnake = exports.memberExpressionOrIdentifier = exports.getFieldDimensionality = exports.importAminoMsg = exports.importAs = exports.importStmt = exports.shorthandProperty = exports.FieldTypeAsts = exports.arrayTypeNDimensions = exports.recursiveNamespace = exports.arrowFunctionExpression = exports.classProperty = exports.classDeclaration = exports.abstractClassDeclaration = exports.promiseTypeAnnotation = exports.typedIdentifier = exports.bindMethod = exports.callExpression = exports.tsObjectPattern = exports.tsPropertySignature = exports.getMessageProperties = exports.tsTypeOperator = exports.identifier = exports.propertySignature = void 0;
+const t = __importStar(require("@babel/types"));
+const case_1 = require("case");
+const ref_1 = require("./ref");
+// t.TSPropertySignature - kind?
+const propertySignature = (name, typeAnnotation, optional = false) => {
+    return {
+        type: 'TSPropertySignature',
+        key: t.identifier(name),
+        kind: 'get',
+        typeAnnotation,
+        optional
+    };
+};
+exports.propertySignature = propertySignature;
+const identifier = (name, typeAnnotation, optional = false) => {
+    const type = t.identifier(name);
+    type.typeAnnotation = typeAnnotation;
+    type.optional = optional;
+    return type;
+};
+exports.identifier = identifier;
+const tsTypeOperator = (typeAnnotation, operator) => {
+    const obj = t.tsTypeOperator(typeAnnotation);
+    obj.operator = operator;
+    return obj;
+};
+exports.tsTypeOperator = tsTypeOperator;
+const getMessageProperties = (msg) => {
+    let results = [];
+    let objs = [];
+    if (msg.anyOf) {
+        objs = msg.anyOf;
+    }
+    else if (msg.oneOf) {
+        objs = msg.oneOf;
+    }
+    else if (msg.allOf) {
+        objs = msg.allOf;
+    }
+    for (const obj of objs) {
+        if (obj.properties) {
+            results.push(obj);
+        }
+        else {
+            if (obj.$ref) {
+                const ref = (0, ref_1.refLookup)(obj.$ref, msg);
+                const refProps = (0, exports.getMessageProperties)(ref);
+                results = [...results, ...refProps];
+            }
+        }
+    }
+    return results;
+};
+exports.getMessageProperties = getMessageProperties;
+const tsPropertySignature = (key, typeAnnotation, optional) => {
+    const obj = t.tsPropertySignature(key, typeAnnotation);
+    obj.optional = optional;
+    return obj;
+};
+exports.tsPropertySignature = tsPropertySignature;
+const tsObjectPattern = (properties, typeAnnotation) => {
+    const obj = t.objectPattern(properties);
+    obj.typeAnnotation = typeAnnotation;
+    return obj;
+};
+exports.tsObjectPattern = tsObjectPattern;
+const callExpression = (callee, _arguments, typeParameters) => {
+    const callExpr = t.callExpression(callee, _arguments);
+    callExpr.typeParameters = typeParameters;
+    return callExpr;
+};
+exports.callExpression = callExpression;
+const bindMethod = (name) => {
+    return t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier(name)), t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier(name)), t.identifier('bind')), [
+        t.thisExpression()
+    ])));
+};
+exports.bindMethod = bindMethod;
+const typedIdentifier = (name, typeAnnotation, optional = false) => {
+    const type = t.identifier(name);
+    type.typeAnnotation = typeAnnotation;
+    type.optional = optional;
+    return type;
+};
+exports.typedIdentifier = typedIdentifier;
+const promiseTypeAnnotation = (name) => {
+    return t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([
+        t.tsTypeReference(t.identifier(name))
+    ])));
+};
+exports.promiseTypeAnnotation = promiseTypeAnnotation;
+const abstractClassDeclaration = (name, body, implementsExressions = [], superClass = null) => {
+    const declaration = (0, exports.classDeclaration)(name, body, implementsExressions, superClass);
+    declaration.abstract = true;
+    return declaration;
+};
+exports.abstractClassDeclaration = abstractClassDeclaration;
+const classDeclaration = (name, body, implementsExressions = [], superClass = null) => {
+    const declaration = t.classDeclaration(t.identifier(name), superClass, t.classBody(body));
+    if (implementsExressions.length) {
+        declaration.implements = implementsExressions;
+    }
+    return declaration;
+};
+exports.classDeclaration = classDeclaration;
+const classProperty = (name, typeAnnotation = null, isReadonly = false, isStatic = false, noImplicitOverride = false) => {
+    const prop = t.classProperty(t.identifier(name));
+    if (isReadonly)
+        prop.readonly = true;
+    if (isStatic)
+        prop.static = true;
+    if (typeAnnotation)
+        prop.typeAnnotation = typeAnnotation;
+    if (noImplicitOverride)
+        prop.override = true;
+    return prop;
+};
+exports.classProperty = classProperty;
+const arrowFunctionExpression = (params, body, returnType, isAsync = false) => {
+    const func = t.arrowFunctionExpression(params, body, isAsync);
+    if (returnType)
+        func.returnType = returnType;
+    return func;
+};
+exports.arrowFunctionExpression = arrowFunctionExpression;
+const recursiveNamespace = (names, moduleBlockBody) => {
+    if (!names || !names.length)
+        return moduleBlockBody;
+    const name = names.pop();
+    const body = [
+        t.exportNamedDeclaration(t.tsModuleDeclaration(t.identifier(name), t.tsModuleBlock((0, exports.recursiveNamespace)(names, moduleBlockBody))))
+    ];
+    return body;
+};
+exports.recursiveNamespace = recursiveNamespace;
+const arrayTypeNDimensions = (body, n) => {
+    if (!n)
+        return t.tsArrayType(body);
+    return t.tsArrayType((0, exports.arrayTypeNDimensions)(body, n - 1));
+};
+exports.arrayTypeNDimensions = arrayTypeNDimensions;
+exports.FieldTypeAsts = {
+    string: () => {
+        return t.tsStringKeyword();
+    },
+    array: (type) => {
+        const result = exports.FieldTypeAsts[type]();
+        return t.tsArrayType(result);
+    },
+    Duration: () => {
+        return t.tsTypeReference(t.identifier('Duration'));
+    },
+    Height: () => {
+        return t.tsTypeReference(t.identifier('Height'));
+    },
+    Coin: () => {
+        return t.tsTypeReference(t.identifier('Coin'));
+    },
+    Long: () => {
+        return t.tsTypeReference(t.identifier('Long'));
+    }
+};
+const shorthandProperty = (prop) => {
+    return t.objectProperty(t.identifier(prop), t.identifier(prop), false, true);
+};
+exports.shorthandProperty = shorthandProperty;
+const importStmt = (names, path) => {
+    return t.importDeclaration(names.map(name => t.importSpecifier(t.identifier(name), t.identifier(name))), t.stringLiteral(path));
+};
+exports.importStmt = importStmt;
+const importAs = (name, importAs, importPath) => {
+    return t.importDeclaration([
+        t.importSpecifier(t.identifier(importAs), t.identifier(name))
+    ], t.stringLiteral(importPath));
+};
+exports.importAs = importAs;
+const importAminoMsg = () => {
+    return (0, exports.importStmt)(['AminoMsg'], '@cosmjs/amino');
+};
+exports.importAminoMsg = importAminoMsg;
+const getFieldDimensionality = (field) => {
+    let typeName = field.type;
+    const isArray = typeName.endsWith('[]');
+    let dimensions = 0;
+    if (isArray) {
+        dimensions = typeName.match(/\[\]/g).length - 1;
+        typeName = typeName.replace(/\[\]/g, '');
+    }
+    return {
+        typeName,
+        dimensions,
+        isArray
+    };
+};
+exports.getFieldDimensionality = getFieldDimensionality;
+const memberExpressionOrIdentifier = (names) => {
+    if (names.length === 1) {
+        return t.identifier(names[0]);
+    }
+    if (names.length === 2) {
+        const [b, a] = names;
+        return t.memberExpression(t.identifier(a), t.identifier(b));
+    }
+    const [name, ...rest] = names;
+    return t.memberExpression((0, exports.memberExpressionOrIdentifier)(rest), t.identifier(name));
+};
+exports.memberExpressionOrIdentifier = memberExpressionOrIdentifier;
+const memberExpressionOrIdentifierSnake = (names) => {
+    if (names.length === 1) {
+        return t.identifier((0, case_1.snake)(names[0]));
+    }
+    if (names.length === 2) {
+        const [b, a] = names;
+        return t.memberExpression(t.identifier((0, case_1.snake)(a)), t.identifier((0, case_1.snake)(b)));
+    }
+    const [name, ...rest] = names;
+    return t.memberExpression((0, exports.memberExpressionOrIdentifierSnake)(rest), t.identifier((0, case_1.snake)(name)));
+};
+exports.memberExpressionOrIdentifierSnake = memberExpressionOrIdentifierSnake;
+/**
+ * If optional, return a conditional, otherwise just the expression
+ */
+const optionalConditionalExpression = (test, expression, alternate, optional = false) => {
+    return optional
+        ? t.conditionalExpression(test, expression, alternate)
+        : expression;
+};
+exports.optionalConditionalExpression = optionalConditionalExpression;
+const typeRefOrUnionWithUndefined = (identifier, optional = false) => {
+    const typeReference = t.tsTypeReference(identifier);
+    return optional
+        ? t.tsUnionType([
+            typeReference,
+            t.tsUndefinedKeyword()
+        ])
+        : typeReference;
+};
+exports.typeRefOrUnionWithUndefined = typeRefOrUnionWithUndefined;
+const parameterizedTypeReference = (identifier, from, omit) => {
+    return t.tsTypeReference(t.identifier(identifier), t.tsTypeParameterInstantiation([
+        from,
+        typeof omit === 'string'
+            ? t.tsLiteralType(t.stringLiteral(omit))
+            : t.tsUnionType(omit.map(o => t.tsLiteralType(t.stringLiteral(o))))
+    ]));
+};
+exports.parameterizedTypeReference = parameterizedTypeReference;
+/**
+ * omitTypeReference(t.tsTypeReference(t.identifier('Cw4UpdateMembersMutation'),),'args').....
+ * Omit<Cw4UpdateMembersMutation, 'args'>
+ */
+const omitTypeReference = (from, omit) => {
+    return (0, exports.parameterizedTypeReference)('Omit', from, omit);
+};
+exports.omitTypeReference = omitTypeReference;
+const pickTypeReference = (from, pick) => {
+    return (0, exports.parameterizedTypeReference)('Pick', from, pick);
+};
+exports.pickTypeReference = pickTypeReference;

package/utils/constants.js

@@ -0,0 +1,46 @@
+"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.PROVIDER_TYPES = exports.FIXED_EXECUTE_PARAMS = exports.OPTIONAL_MEMO_PARAM = exports.OPTIONAL_FEE_PARAM = exports.OPTIONAL_FUNDS_PARAM = void 0;
+const babel_1 = require("./babel");
+const t = __importStar(require("@babel/types"));
+exports.OPTIONAL_FUNDS_PARAM = (0, babel_1.identifier)('_funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true);
+exports.OPTIONAL_FEE_PARAM = (0, babel_1.identifier)('fee', t.tsTypeAnnotation(t.tsUnionType([
+    t.tsNumberKeyword(),
+    t.tsTypeReference(t.identifier('StdFee')),
+    t.tsLiteralType(t.stringLiteral('auto'))
+])), true);
+exports.OPTIONAL_MEMO_PARAM = (0, babel_1.identifier)('memo', t.tsTypeAnnotation(t.tsStringKeyword()), true);
+exports.FIXED_EXECUTE_PARAMS = [
+    exports.OPTIONAL_FEE_PARAM,
+    exports.OPTIONAL_MEMO_PARAM,
+    exports.OPTIONAL_FUNDS_PARAM
+];
+exports.PROVIDER_TYPES = {
+    SIGNING_CLIENT_TYPE: "client",
+    QUERY_CLIENT_TYPE: "queryClient",
+    MESSAGE_COMPOSER_TYPE: 'message-composer',
+    PROVIDER_TYPE: 'provider'
+};

package/utils/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_TYPES = exports.FIXED_EXECUTE_PARAMS = exports.OPTIONAL_FUNDS_PARAM = void 0;
+__exportStar(require("./babel"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./ref"), exports);
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "OPTIONAL_FUNDS_PARAM", { enumerable: true, get: function () { return constants_1.OPTIONAL_FUNDS_PARAM; } });
+var constants_2 = require("./constants");
+Object.defineProperty(exports, "FIXED_EXECUTE_PARAMS", { enumerable: true, get: function () { return constants_2.FIXED_EXECUTE_PARAMS; } });
+var constants_3 = require("./constants");
+Object.defineProperty(exports, "PROVIDER_TYPES", { enumerable: true, get: function () { return constants_3.PROVIDER_TYPES; } });

package/{types/utils → utils}/ref.d.ts

@@ -1,2 +1,2 @@
-import { JSONSchema } from "../types";
+import { JSONSchema } from "@cosmology/ts-codegen-types";
 export declare const refLookup: ($ref: string, schema: JSONSchema) => JSONSchema;

package/utils/ref.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refLookup = void 0;
+const refLookup = ($ref, schema) => {
+    const refName = $ref.replace('#/definitions/', '');
+    return schema.definitions?.[refName];
+};
+exports.refLookup = refLookup;

package/{types/utils → utils}/types.d.ts

@@ -1,20 +1,20 @@
 import * as t from '@babel/types';
-import { TSTypeAnnotation } from '@babel/types';
 import { RenderContext } from '../context';
-import { JSONSchema } from '../types';
+import { JSONSchema } from '@cosmology/ts-codegen-types';
 export declare function getResponseType(context: RenderContext, underscoreName: string): string;
-export declare const getTypeFromRef: ($ref: any) => t.TSTypeReference;
+export declare const getTypeFromRef: ($ref: string) => t.TSTypeReference;
+export declare const getTypeOrRef: (obj: JSONSchema) => t.TSType;
 export declare const detectType: (type: string | string[]) => {
     type: string;
     optional: boolean;
 };
-export declare const getTypeInfo: (info: JSONSchema) => {
-    type: any;
-    optional: any;
+export declare const getTypeInfo: (context: RenderContext, info: JSONSchema) => {
+    type: t.TSBooleanKeyword | t.TSNullKeyword | t.TSNumberKeyword | t.TSStringKeyword | t.TSTypeReference | t.TSArrayType;
+    optional: boolean;
 };
-export declare const getType: (type: string) => t.TSBooleanKeyword | t.TSNumberKeyword | t.TSStringKeyword;
+export declare const getType: (type: string) => t.TSBooleanKeyword | t.TSNullKeyword | t.TSNumberKeyword | t.TSStringKeyword;
 export declare const getPropertyType: (context: RenderContext, schema: JSONSchema, prop: string) => {
-    type: any;
+    type: t.TSBooleanKeyword | t.TSNullKeyword | t.TSNumberKeyword | t.TSStringKeyword | t.TSTypeReference | t.TSArrayType;
     optional: boolean;
 };
 export declare function getPropertySignatureFromProp(context: RenderContext, jsonschema: JSONSchema, prop: string, camelize: boolean): t.TSPropertySignature;