@hyperweb/telescope 2.0.4 → 2.2.0

package/src/imports.ts

@@ -1,499 +0,0 @@
-import * as t from "@babel/types";
-import {
-  GenericParseContext,
-  SymbolNames,
-  TelescopeBaseTypes,
-  importStmt,
-} from "@cosmology/ast";
-import { ServiceMutation } from "@cosmology/types";
-
-import { DerivedImportObj, ImportHash, ImportObj } from "./types";
-import { UTILS, getRelativePath, UTIL_HELPERS } from "./utils";
-import { TelescopeParseContext } from "./build";
-import { restoreExtension } from "@cosmology/utils";
-
-const importHashToArray = (hash: ImportHash): ImportObj[] => {
-  return Object.entries(hash ?? {}).reduce((m, [path, names]) => {
-    names.forEach((name) => {
-      m.push({
-        type: "import",
-        name,
-        path,
-      });
-    });
-    return m;
-  }, []);
-};
-
-const getProtoImports = (
-  context: TelescopeParseContext,
-  filename: string
-): ImportObj[] => {
-  return context.proto.imports
-    .map((usage) => {
-      if (filename === usage.import) return;
-      const importPath = getRelativePath(filename, usage.import);
-      return {
-        type: "import",
-        name: usage.name,
-        importAs: usage.importedAs,
-        path: importPath,
-        protoPath: usage.import,
-      };
-    })
-    .filter(Boolean);
-};
-
-const getAminoImports = (
-  context: TelescopeParseContext,
-  filename: string
-): ImportObj[] => {
-  return context.amino.imports
-    .map((usage) => {
-      if (filename === usage.import) return;
-      const importPath = getRelativePath(filename, usage.import);
-      return {
-        type: "import",
-        name: usage.name,
-        importAs: usage.importedAs,
-        path: importPath,
-        protoPath: usage.import,
-      };
-    })
-    .filter(Boolean);
-};
-
-const getGenericImports = (
-  context: TelescopeParseContext,
-  filename: string
-): ImportObj[] => {
-  return context.generic.imports
-    .map((usage) => {
-      if (filename === usage.import) return;
-      const importPath = getRelativePath(filename, usage.import);
-      return {
-        type: "import",
-        name: usage.name,
-        importAs: usage.importedAs,
-        path: importPath,
-        protoPath: usage.import,
-      };
-    })
-    .filter(Boolean);
-};
-
-const getParsedImports = (
-  context: TelescopeParseContext,
-  parsedImports: ImportHash,
-  filename: string
-): ImportObj[] => {
-  const imports = [];
-  Object.entries(parsedImports ?? {}).forEach(([path, names]) => {
-    if (filename === path) return;
-    const importPath = getRelativePath(filename, path);
-    const aliases = context.ref?.traversed?.importNames?.[path];
-    names.forEach((name) => {
-      let importAs = name;
-      if (aliases && aliases[name]) {
-        importAs = aliases[name];
-      }
-      imports.push({
-        type: "import",
-        name,
-        importAs,
-        path: importPath,
-        protoPath: path,
-      });
-    });
-  });
-  return imports;
-};
-
-const importAs = (name: string, importAs: string, importPath: string) => {
-  return t.importDeclaration(
-    [t.importSpecifier(t.identifier(importAs), t.identifier(name))],
-    t.stringLiteral(importPath)
-  );
-};
-
-// __helpers__
-export const getImportStatements = (
-  filepath: string,
-  list: ImportObj[],
-  options?: {
-    restoreImportExtension?: string;
-  }
-) => {
-  const imports = list.reduce((m, obj) => {
-    let editedPath = UTIL_HELPERS.includes(obj.path)
-      ? getRelativePath(filepath, `./${obj.path.replace(/__/g, "")}`)
-      : obj.path;
-
-    editedPath = restoreExtension(editedPath, options?.restoreImportExtension);
-
-    const clonedObj = { ...obj, path: editedPath };
-
-    m[clonedObj.path] = m[clonedObj.path] || [];
-    const exists = m[clonedObj.path].find(
-      (el) =>
-        el.type === clonedObj.type &&
-        el.path === clonedObj.path &&
-        el.name === clonedObj.name
-    );
-
-    // MARKED AS NOT DRY [google.protobuf names]
-    // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
-    if (/\./.test(clonedObj.name)) {
-      clonedObj.name =
-        clonedObj.name.split(".")[clonedObj.name.split(".").length - 1];
-    }
-
-    if (!exists) {
-      m[clonedObj.path].push(clonedObj);
-    }
-    return m;
-  }, {});
-
-  return Object.entries(imports).reduce(
-    (m, [importPath, imports]: [string, ImportObj[]]) => {
-      const defaultImports = imports.filter((a) => a.type === "default");
-      if (defaultImports.length) {
-        if (defaultImports.length > 1)
-          throw new Error("more than one default name NOT allowed.");
-        m.push(
-          t.importDeclaration(
-            [t.importDefaultSpecifier(t.identifier(defaultImports[0].name))],
-            t.stringLiteral(defaultImports[0].path)
-          )
-        );
-      }
-      const namedImports = imports.filter(
-        (a) => a.type === "import" && (!a.importAs || a.name === a.importAs)
-      );
-      if (namedImports.length) {
-        m.push(
-          importStmt(
-            namedImports.map((i) => i.name),
-            namedImports[0].path
-          )
-        );
-      }
-      const aliasNamedImports = imports.filter(
-        (a) => a.type === "import" && a.importAs && a.name !== a.importAs
-      );
-      aliasNamedImports.forEach((imp) => {
-        m.push(importAs(imp.name, imp.importAs, imp.path));
-      });
-
-      const namespaced = imports.filter((a) => a.type === "namespace");
-      if (namespaced.length) {
-        if (namespaced.length > 1)
-          throw new Error("more than one namespaced name NOT allowed.");
-        m.push(
-          t.importDeclaration(
-            [t.importNamespaceSpecifier(t.identifier(namespaced[0].name))],
-            t.stringLiteral(namespaced[0].path)
-          )
-        );
-      }
-      return m;
-    },
-    []
-  );
-};
-
-const convertUtilsToImports = (context: TelescopeParseContext): ImportObj[] => {
-  const list = [];
-  const utils = Object.keys({
-    ...context.amino.utils,
-    ...context.proto.utils,
-    ...context.generic.utils,
-  });
-
-  utils.forEach((util) => {
-    if (!UTILS.hasOwnProperty(util)) throw new Error("missing Util! ::" + util);
-    if (typeof UTILS[util] === "string") {
-      list.push({
-        type: "import",
-        path: UTILS[util],
-        name: util,
-      });
-    } else {
-      list.push(UTILS[util]);
-    }
-  });
-  return list;
-};
-
-const convertUtilsToImportsGenric = (
-  context: GenericParseContext
-): ImportObj[] => {
-  const list = [];
-  const utils = Object.keys({
-    ...context.utils,
-  });
-
-  // MARKED AS NOT DRY - duplicate of above
-  utils.forEach((util) => {
-    if (!UTILS.hasOwnProperty(util)) throw new Error("missing Util! ::" + util);
-    if (typeof UTILS[util] === "string") {
-      list.push({
-        type: "import",
-        path: UTILS[util],
-        name: util,
-      });
-    } else {
-      list.push(UTILS[util]);
-    }
-  });
-  return list;
-};
-
-export const buildAllImports = (
-  context: TelescopeParseContext,
-  allImports: ImportHash,
-  filepath: string
-) => {
-  const imports = aggregateImports(context, allImports, filepath);
-  const importStmts = getImportStatements(filepath, imports, {
-    restoreImportExtension: context.options.restoreImportExtension,
-  });
-  return importStmts;
-};
-
-export const buildAllImportsFromGenericContext = (
-  context: GenericParseContext,
-  filepath: string
-) => {
-  const imports: ImportObj[] = convertUtilsToImportsGenric(context);
-  const importStmts = getImportStatements(filepath, imports, {
-    restoreImportExtension: context.options.restoreImportExtension,
-  });
-  return importStmts;
-};
-
-const addDerivativeTypesToImports = (
-  context: TelescopeParseContext,
-  imports: ImportObj[]
-) => {
-  const ref = context.ref;
-
-  return imports.reduce((m, obj) => {
-    // SDKType
-    // probably wont need this until we start generating osmonauts/helpers inline
-    if (obj.type === "import" && obj.path.startsWith(".")) {
-      let lookup = null;
-      try {
-        lookup = context.store.getImportFromRef(ref, obj.name);
-      } catch (e) {}
-
-      const appendSuffix = (
-        obj: ImportObj,
-        baseType: TelescopeBaseTypes
-      ): DerivedImportObj => {
-        return {
-          ...obj,
-          orig: obj.name,
-          name: SymbolNames[baseType](obj.name),
-          importAs: SymbolNames[baseType](obj.importAs ?? obj.name),
-          protoPath: obj.protoPath,
-        };
-      };
-
-      // MARKED AS NOT DRY [google.protobuf names]
-      // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
-      const removeProtoPrefix = (obj: DerivedImportObj): DerivedImportObj => {
-        if (/\./.test(obj.name)) {
-          obj.name = obj.name.split(".")[obj.name.split(".").length - 1];
-          obj.importAs =
-            obj.importAs.split(".")[obj.importAs.split(".").length - 1];
-        }
-        return obj;
-      };
-
-      const SDKTypeObject = removeProtoPrefix(appendSuffix(obj, "SDKType"));
-      const AminoTypeObject = removeProtoPrefix(appendSuffix(obj, "Amino"));
-      const EncodedTypeObject = removeProtoPrefix(
-        appendSuffix(obj, "ProtoMsg")
-      );
-      // const AminoTypeUrlObject = removeProtoPrefix(appendSuffix(obj, 'AminoType'));
-
-      if (lookup && ["Type", "Enum"].includes(lookup.obj.type)) {
-        const arr = [...m, obj];
-
-        if (
-          context.options.aminoEncoding?.enabled &&
-          !context.options.aminoEncoding.useLegacyInlineEncoding
-        ) {
-          // check and see if this derived import has been required...
-          const foundEnc = context.proto.derivedImports.find((a) => {
-            if (a.type !== "ProtoMsg") return false;
-            if (EncodedTypeObject.orig === a.symbol.symbolName) {
-              // UNTIL you fix the ImportObjs to have ref...
-              let rel = getRelativePath(a.symbol.ref, a.symbol.source);
-              if (rel === EncodedTypeObject.path) {
-                return true;
-              }
-            }
-          });
-          const foundAmino = context.proto.derivedImports.find((a) => {
-            if (a.type !== "Amino") return false;
-            if (
-              AminoTypeObject.orig === a.symbol.symbolName &&
-              a.symbol.ref &&
-              a.symbol.source
-            ) {
-              // UNTIL you fix the ImportObjs to have ref...
-              let rel = getRelativePath(a.symbol.ref, a.symbol.source);
-              if (rel === AminoTypeObject.path) {
-                return true;
-              }
-            }
-          });
-
-          // we need Any types as defaults...
-          if (foundEnc || EncodedTypeObject.orig === "Any") {
-            arr.push(EncodedTypeObject);
-          }
-          if (foundAmino || AminoTypeObject.orig === "Any") {
-            arr.push(AminoTypeObject);
-          }
-        }
-        if (context.options.useSDKTypes) {
-          // issue in output1 (probably legacy v1 amino transpiler)
-          // ProposalSDKType wasn't being found in QueryProposalResponseSDKType
-          arr.push(SDKTypeObject);
-          // const foundSDK = context.proto.derivedImports.find(a => {
-          //     if (a.type !== 'SDKType') return false;
-
-          //     if (SDKTypeObject.orig === a.symbol.symbolName) {
-          //         // UNTIL you fix the ImportObjs to have ref...
-          //         let rel = getRelativePath(a.symbol.ref, a.symbol.source);
-          //         if (rel === SDKTypeObject.path) {
-          //             return true;
-          //         }
-          //     }
-          // });
-
-          // if (foundSDK) {
-          //     arr.push(SDKTypeObject);
-          // }
-        }
-
-        return arr;
-      }
-    }
-    return [...m, obj];
-  }, []);
-};
-
-export const aggregateImports = (
-  context: TelescopeParseContext,
-  allImports: ImportHash,
-  filepath: string
-): ImportObj[] => {
-  const protoImports: ImportObj[] = getProtoImports(context, filepath);
-  const aminoImports: ImportObj[] = getAminoImports(context, filepath);
-  const genericImports: ImportObj[] = getGenericImports(context, filepath);
-  const parsedImports: ImportObj[] = getParsedImports(
-    context,
-    context.amino.ref.traversed.parsedImports,
-    filepath
-  );
-  const additionalImports: ImportObj[] = importHashToArray(allImports);
-  const utilities: ImportObj[] = convertUtilsToImports(context);
-
-  let list = []
-    .concat(parsedImports)
-    .concat(utilities)
-    .concat(protoImports)
-    .concat(aminoImports)
-    .concat(genericImports)
-    .concat(additionalImports);
-
-  if (
-    context.options.useSDKTypes ||
-    (context.options.aminoEncoding?.enabled &&
-      !context.options.aminoEncoding?.useLegacyInlineEncoding)
-  ) {
-    list = addDerivativeTypesToImports(context, list);
-  }
-
-  list = list.filter((imp) => {
-    const alias = context.store.getTypeAlias(imp.orig || imp.name, imp.protoPath);
-    return !alias;
-  });
-
-  return list;
-};
-
-export const getImportsFromMutations = (mutations: ServiceMutation[]) => {
-  return mutations.map((mutation) => {
-    return {
-      import: mutation.messageImport,
-      name: mutation.message,
-    };
-  });
-};
-
-// TODO implement ServiceQuery type (it is the same)
-export const getImportsFromQueries = (queries: ServiceMutation[]) => {
-  return queries.reduce((m, query) => {
-    const req = {
-      import: query.messageImport,
-      name: query.message,
-    };
-    const res = {
-      import: query.responseImport,
-      name: query.response,
-    };
-    return [...m, req, res];
-  }, []);
-};
-
-export const getDepsFromMutations = (
-  mutations: ServiceMutation[],
-  filename: string
-) => {
-  return getImportsFromMutations(mutations)
-    .map((imp) => {
-      const f = filename;
-      const f2 = imp.import;
-      if (f === f2) return;
-      const importPath = getRelativePath(f, f2);
-      return {
-        ...imp,
-        importPath,
-      };
-    })
-    .filter(Boolean)
-    .reduce((m, v) => {
-      m[v.importPath] = m[v.importPath] ?? [];
-      if (!m[v.importPath].includes(v.name)) {
-        m[v.importPath].push(v.name);
-      }
-      return m;
-    }, {});
-};
-
-export const getDepsFromQueries = (queries: any[], filename: string) => {
-  return getImportsFromQueries(queries)
-    .map((imp) => {
-      const f = filename;
-      const f2 = imp.import;
-      if (f === f2) return;
-      const importPath = getRelativePath(f, f2);
-      return {
-        ...imp,
-        importPath,
-      };
-    })
-    .filter(Boolean)
-    .reduce((m, v) => {
-      m[v.importPath] = m[v.importPath] ?? [];
-      if (!m[v.importPath].includes(v.name)) {
-        m[v.importPath].push(v.name);
-      }
-      return m;
-    }, {});
-};

package/src/index.ts

@@ -1,12 +0,0 @@
-import { TelescopeInput } from './types';
-import { TelescopeBuilder } from './builder';
-
-export * from './builder';
-export * from './bundler';
-export * from './types';
-
-export default async (input: TelescopeInput) => {
-    const builder = new TelescopeBuilder(input);
-    await builder.build();
-};
-