npm - @pezkuwi/typegen - Versions diffs - 16.5.5 - Mend

@pezkuwi/typegen 16.5.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (99) hide show

package/README.md +3 -0
package/build/augment.d.ts +2 -0
package/build/bundle.d.ts +2 -0
package/build/extractChain.d.ts +1 -0
package/build/fromChain.d.ts +1 -0
package/build/fromDefs.d.ts +1 -0
package/build/generate/consts.d.ts +5 -0
package/build/generate/errors.d.ts +4 -0
package/build/generate/events.d.ts +5 -0
package/build/generate/index.d.ts +10 -0
package/build/generate/interfaceRegistry.d.ts +4 -0
package/build/generate/lookup.d.ts +4 -0
package/build/generate/query.d.ts +5 -0
package/build/generate/rpc.d.ts +6 -0
package/build/generate/runtime.d.ts +7 -0
package/build/generate/tsDef.d.ts +16 -0
package/build/generate/tx.d.ts +5 -0
package/build/generate/types.d.ts +12 -0
package/build/index.d.ts +2 -0
package/build/interfacesTs.d.ts +1 -0
package/build/metadataMd.d.ts +1 -0
package/build/packageDetect.d.ts +1 -0
package/build/packageInfo.d.ts +6 -0
package/build/scripts/polkadot-types-chain-info.mjs +7 -0
package/build/scripts/polkadot-types-from-chain.mjs +7 -0
package/build/scripts/polkadot-types-from-defs.mjs +7 -0
package/build/scripts/polkadot-types-internal-interfaces.mjs +7 -0
package/build/scripts/polkadot-types-internal-metadata.mjs +7 -0
package/build/util/assert.d.ts +2 -0
package/build/util/derived.d.ts +4 -0
package/build/util/docs.d.ts +1 -0
package/build/util/file.d.ts +2 -0
package/build/util/formatting.d.ts +11 -0
package/build/util/imports.d.ts +23 -0
package/build/util/index.d.ts +15 -0
package/build/util/initMeta.d.ts +12 -0
package/build/util/register.d.ts +4 -0
package/build/util/wsMeta.d.ts +4 -0
package/package.json +52 -0
package/scripts/polkadot-types-chain-info.mjs +7 -0
package/scripts/polkadot-types-from-chain.mjs +7 -0
package/scripts/polkadot-types-from-defs.mjs +7 -0
package/scripts/polkadot-types-internal-interfaces.mjs +7 -0
package/scripts/polkadot-types-internal-metadata.mjs +7 -0
package/src/augment.ts +5 -0
package/src/bundle.ts +5 -0
package/src/extractChain.ts +54 -0
package/src/fromChain.ts +123 -0
package/src/fromDefs.ts +106 -0
package/src/generate/consts.ts +112 -0
package/src/generate/errors.ts +75 -0
package/src/generate/events.ts +165 -0
package/src/generate/index.ts +13 -0
package/src/generate/interfaceRegistry.ts +85 -0
package/src/generate/lookup.ts +294 -0
package/src/generate/query.ts +169 -0
package/src/generate/rpc.ts +158 -0
package/src/generate/runtime.ts +284 -0
package/src/generate/tsDef.ts +321 -0
package/src/generate/tx.ts +152 -0
package/src/generate/types.ts +26 -0
package/src/index.ts +6 -0
package/src/interfacesTs.ts +35 -0
package/src/metadataMd.ts +844 -0
package/src/packageDetect.ts +14 -0
package/src/packageInfo.ts +6 -0
package/src/templates/calls.hbs +30 -0
package/src/templates/consts.hbs +28 -0
package/src/templates/docs.hbs +7 -0
package/src/templates/errors.hbs +28 -0
package/src/templates/events.hbs +28 -0
package/src/templates/header.hbs +2 -0
package/src/templates/interfaceRegistry.hbs +15 -0
package/src/templates/lookup/defs-named.hbs +12 -0
package/src/templates/lookup/defs.hbs +15 -0
package/src/templates/lookup/index.hbs +3 -0
package/src/templates/lookup/types.hbs +14 -0
package/src/templates/query.hbs +29 -0
package/src/templates/rpc.hbs +22 -0
package/src/templates/tsDef/index.hbs +3 -0
package/src/templates/tsDef/moduleTypes.hbs +10 -0
package/src/templates/tsDef/types.hbs +7 -0
package/src/templates/tx.hbs +30 -0
package/src/util/assert.ts +18 -0
package/src/util/derived.spec.ts +58 -0
package/src/util/derived.ts +133 -0
package/src/util/docs.ts +13 -0
package/src/util/file.ts +42 -0
package/src/util/formatting.spec.ts +30 -0
package/src/util/formatting.ts +295 -0
package/src/util/imports.ts +164 -0
package/src/util/index.ts +18 -0
package/src/util/initMeta.ts +37 -0
package/src/util/register.ts +12 -0
package/src/util/wsMeta.ts +70 -0
package/tsconfig.build.json +28 -0
package/tsconfig.build.tsbuildinfo +1 -0
package/tsconfig.scripts.json +19 -0
package/tsconfig.spec.json +17 -0

package/src/util/formatting.ts ADDED Viewed

@@ -0,0 +1,295 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { AnyString, Registry } from '@pezkuwi/types/types';
+import type { LookupString } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { ModuleTypes, TypeImports } from './imports.js';
+import Handlebars from 'handlebars';
+import * as typesCodec from '@pezkuwi/types-codec';
+import { getTypeDef, paramsNotation, TypeDefInfo } from '@pezkuwi/types-create';
+import { isString, stringify } from '@pezkuwi/util';
+import { readTemplate } from './file.js';
+import { setImports } from './imports.js';
+interface ImportDef {
+  file: string;
+  types: string[];
+}
+interface This {
+  imports: TypeImports;
+  types: ImportDef[];
+}
+const NO_CODEC = ['Tuple', 'VecFixed'];
+const ON_CODEC = Object.keys(typesCodec);
+const ON_CODEC_TYPES = ['Codec', 'AnyJson', 'AnyFunction', 'AnyNumber', 'AnyString', 'AnyTuple', 'AnyU8a', 'ICompact', 'IEnum', 'IMap', 'INumber', 'IOption', 'IResult', 'ISet', 'IStruct', 'ITuple', 'IU8a', 'IVec', 'IMethod'];
+export const HEADER = (type: 'chain' | 'defs'): string => `// Auto-generated via \`yarn polkadot-types-from-${type}\`, do not edit\n/* eslint-disable */\n\n`;
+function extractImports ({ imports, types }: This): string[] {
+  const toplevel = [
+    ...Object.keys(imports.codecTypes),
+    ...Object.keys(imports.extrinsicTypes),
+    ...Object.keys(imports.genericTypes),
+    ...Object.keys(imports.metadataTypes),
+    ...Object.keys(imports.primitiveTypes)
+  ];
+  return [
+    {
+      file: '@pezkuwi/types',
+      types: toplevel.filter((n) =>
+        !NO_CODEC.includes(n) && !ON_CODEC.includes(n)
+      )
+    },
+    {
+      file: '@pezkuwi/types/lookup',
+      types: Object.keys(imports.lookupTypes)
+    },
+    {
+      file: '@pezkuwi/types/types',
+      types: Object.keys(imports.typesTypes).filter((n) =>
+        !ON_CODEC_TYPES.includes(n)
+      )
+    },
+    {
+      file: '@pezkuwi/types-codec',
+      types: toplevel.filter((n) =>
+        !NO_CODEC.includes(n) && ON_CODEC.includes(n)
+      )
+    },
+    {
+      file: '@pezkuwi/types-codec/types',
+      types: Object.keys(imports.typesTypes).filter((n) =>
+        ON_CODEC_TYPES.includes(n)
+      )
+    },
+    ...types
+  ]
+    .filter(({ types }) => types.length)
+    .sort(({ file }, b) => file.localeCompare(b.file))
+    .map(({ file, types }) => `import type { ${types.sort().join(', ')} } from '${file}';`);
+}
+Handlebars.registerPartial({
+  header: Handlebars.compile(readTemplate('header'))
+});
+Handlebars.registerHelper({
+  importsAll () {
+    return extractImports(this as unknown as This)
+      .join('\n');
+  },
+  importsPackage () {
+    return extractImports(this as unknown as This)
+      .filter((l) => !l.includes("from '."))
+      .join('\n  ');
+  },
+  importsRelative () {
+    return extractImports(this as unknown as This)
+      .filter((l) => l.includes("from '."))
+      .join('\n');
+  },
+  trim (options: { fn: (self: unknown) => string }) {
+    return options.fn(this).trim();
+  },
+  upper (options: { fn: (self: unknown) => string }) {
+    return options.fn(this).toUpperCase();
+  }
+});
+// helper to generate a `export interface <Name> extends <Base> {<Body>}
+/** @internal */
+export function exportInterface (lookupIndex = -1, name = '', base: string, body = '', withShortcut = false): string {
+  // * @description extends [[${base}]]
+  const doc = withShortcut
+    ? ''
+    : `/** @name ${name}${lookupIndex !== -1 ? ` (${lookupIndex})` : ''} */\n`;
+  return `${doc}${withShortcut ? '' : `export interface ${name} extends ${base} `}{${body.length ? '\n' : ''}${body}${withShortcut ? '  ' : ''}}`;
+}
+function singleParamNotation (registry: Registry, wrapper: string, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean): string {
+  const sub = (typeDef.sub as TypeDef);
+  setImports(definitions, imports, [wrapper, sub.lookupName]);
+  return paramsNotation(wrapper, sub.lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
+}
+function dualParamsNotation (registry: Registry, wrapper: string, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean): string {
+  const [a, b] = (typeDef.sub as TypeDef[]);
+  setImports(definitions, imports, [wrapper, a.lookupName, b.lookupName]);
+  return paramsNotation(wrapper, [
+    a.lookupName || formatType(registry, definitions, a.type, imports, withShortcut),
+    b.lookupName || formatType(registry, definitions, b.type, imports, withShortcut)
+  ]);
+}
+const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => string> = {
+  [TypeDefInfo.Compact]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return singleParamNotation(registry, 'Compact', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.DoNotConstruct]: (_registry: Registry, _typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, _withShortcut: boolean) => {
+    setImports(definitions, imports, ['DoNotConstruct']);
+    return 'DoNotConstruct';
+  },
+  [TypeDefInfo.Enum]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
+    if (typeDef.lookupName) {
+      return typeDef.lookupName;
+    }
+    throw new Error(`TypeDefInfo.Enum: Parameter formatting not implemented on ${stringify(typeDef)}`);
+  },
+  [TypeDefInfo.Int]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
+    throw new Error(`TypeDefInfo.Int: Parameter formatting not implemented on ${stringify(typeDef)}`);
+  },
+  [TypeDefInfo.UInt]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
+    throw new Error(`TypeDefInfo.UInt: Parameter formatting not implemented on ${stringify(typeDef)}`);
+  },
+  [TypeDefInfo.Null]: (_registry: Registry, _typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, _withShortcut: boolean) => {
+    setImports(definitions, imports, ['Null']);
+    return 'Null';
+  },
+  [TypeDefInfo.Option]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return singleParamNotation(registry, 'Option', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.Plain]: (_registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, _withShortcut: boolean) => {
+    setImports(definitions, imports, [typeDef.type]);
+    return typeDef.type;
+  },
+  [TypeDefInfo.Range]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return singleParamNotation(registry, 'Range', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.RangeInclusive]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return singleParamNotation(registry, 'RangeInclusive', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.Set]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
+    throw new Error(`TypeDefInfo.Set: Parameter formatting not implemented on ${stringify(typeDef)}`);
+  },
+  [TypeDefInfo.Si]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return formatType(registry, definitions, registry.lookup.getTypeDef(typeDef.type as LookupString), imports, withShortcut);
+  },
+  [TypeDefInfo.Struct]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    if (typeDef.lookupName) {
+      return typeDef.lookupName;
+    }
+    const sub = typeDef.sub as TypeDef[];
+    setImports(definitions, imports, ['Struct', ...sub.map(({ lookupName }) => lookupName)]);
+    return `{${withShortcut ? ' ' : '\n'}${
+      sub.map(({ lookupName, name, type }, index) => [
+        name || `unknown${index}`,
+        lookupName || formatType(registry, definitions, type, imports, withShortcut)
+      ]).map(([k, t]) => `${withShortcut ? '' : '    readonly '}${k}: ${t};`).join(withShortcut ? ' ' : '\n')
+    }${withShortcut ? ' ' : '\n  '}} & Struct`;
+  },
+  [TypeDefInfo.Tuple]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    const sub = typeDef.sub as TypeDef[];
+    setImports(definitions, imports, ['ITuple', ...sub.map(({ lookupName }) => lookupName)]);
+    // `(a,b)` gets transformed into `ITuple<[a, b]>`
+    return paramsNotation('ITuple', `[${
+      sub.map(({ lookupName, type }) =>
+        lookupName || formatType(registry, definitions, type, imports, withShortcut)
+      ).join(', ')
+    }]`);
+  },
+  [TypeDefInfo.Vec]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.VecFixed]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    const sub = (typeDef.sub as TypeDef);
+    if (sub.type === 'u8') {
+      setImports(definitions, imports, ['U8aFixed']);
+      return 'U8aFixed';
+    }
+    return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.BTreeMap]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return dualParamsNotation(registry, 'BTreeMap', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.BTreeSet]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return singleParamNotation(registry, 'BTreeSet', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.HashMap]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return dualParamsNotation(registry, 'HashMap', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.Linkage]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return singleParamNotation(registry, 'Linkage', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.Result]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return dualParamsNotation(registry, 'Result', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.WrapperKeepOpaque]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return singleParamNotation(registry, 'WrapperKeepOpaque', typeDef, definitions, imports, withShortcut);
+  },
+  [TypeDefInfo.WrapperOpaque]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
+    return singleParamNotation(registry, 'WrapperOpaque', typeDef, definitions, imports, withShortcut);
+  }
+};
+/**
+ * Correctly format a given type
+ */
+/** @internal */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function formatType (registry: Registry, definitions: Record<string, ModuleTypes>, type: AnyString | TypeDef, imports: TypeImports, withShortcut = false): string {
+  let typeDef: TypeDef;
+  if (isString(type)) {
+    const _type = type.toString();
+    // If type is "unorthodox" (i.e. `{ something: any }` for an Enum input or `[a | b | c, d | e | f]` for a Tuple's similar types),
+    // we return it as-is
+    if (withShortcut && /(^{.+:.+})|^\([^,]+\)|^\(.+\)\[\]|^\[.+\]/.exec(_type) && !/\[\w+;\w+\]/.exec(_type)) {
+      return _type;
+    }
+    typeDef = getTypeDef(type);
+  } else {
+    typeDef = type;
+  }
+  setImports(definitions, imports, [typeDef.lookupName || typeDef.type]);
+  return formatters[typeDef.info](registry, typeDef, definitions, imports, withShortcut);
+}

package/src/util/imports.ts ADDED Viewed

@@ -0,0 +1,164 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import * as codecClasses from '@pezkuwi/types/codec';
+import * as extrinsicClasses from '@pezkuwi/types/extrinsic';
+import * as genericClasses from '@pezkuwi/types/generic';
+import * as primitiveClasses from '@pezkuwi/types/primitive';
+import { getTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
+export interface ModuleTypes {
+  types: Record<string, unknown>;
+}
+// these map all the codec and primitive types for import, see the TypeImports below. If
+// we have an unseen type, it is `undefined`/`false`, if we need to import it, it is `true`
+type TypeExist = Record<string, boolean>;
+// local and absolute imports map to this format
+// { [moduleName]: { [typeName]: true } }
+type TypeExistMap = Record<string, TypeExist>;
+export interface TypeImports {
+  codecTypes: TypeExist; // `import {} from '@pezkuwi/types/codec`
+  extrinsicTypes: TypeExist; // `import {} from '@pezkuwi/types/extrinsic`
+  genericTypes: TypeExist; // `import {} from '@pezkuwi/types/generic`
+  ignoredTypes: string[]; // No need to import these types
+  localTypes: TypeExistMap; // `import {} from '../something'`
+  lookupTypes: TypeExistMap; // `import {} from '@pezkuwi/types/lookup`
+  primitiveTypes: TypeExist; // `import {} from '@pezkuwi/types/primitive`
+  metadataTypes: TypeExist; // `import {} from '@pezkuwi/types/metadata`
+  typesTypes: TypeExist; // `import {} from '@pezkuwi/types/types`
+  definitions: Record<string, ModuleTypes>; // all definitions
+  typeToModule: Record<string, string>;
+}
+// returns the top-level types in the alternatives list, taking into account nested [], <> and () items
+// E.g. for the string '[a<b,c>, d | e]' we return the array ['a<b,c>', 'd', 'e']
+function splitAlternatives (type: string): string[] {
+  const alternatives = [];
+  let beginOfAlternative = 1;
+  let level = 0;
+  // we assume that the string starts with '['
+  for (let i = 1, count = type.length; i < count; i++) {
+    if (level === 0) {
+      switch (type[i]) {
+        case ']':
+        case ',':
+        case '|':
+          alternatives.push(type.substring(beginOfAlternative, i).trim());
+          beginOfAlternative = i + 1;
+          break;
+      }
+    }
+    switch (type[i]) {
+      case '[':
+      case '(':
+      case '<':
+        level++;
+        break;
+      case ']':
+      case ')':
+      case '>':
+        level--;
+        break;
+    }
+  }
+  return alternatives;
+}
+// Maps the types as found to the source location. This is used to generate the
+// imports in the output file, dep-duped and sorted
+/** @internal */
+export function setImports (allDefs: Record<string, ModuleTypes>, imports: TypeImports, types: (string | null | undefined)[]): void {
+  const { codecTypes, extrinsicTypes, genericTypes, ignoredTypes, localTypes, metadataTypes, primitiveTypes, typesTypes } = imports;
+  types.filter((t): t is string => !!t).forEach((type): void => {
+    if (ignoredTypes.includes(type)) {
+      // do nothing
+    } else if (['AnyNumber', 'CallFunction', 'Codec', 'IExtrinsic', 'IMethod', 'ITuple'].includes(type)) {
+      typesTypes[type] = true;
+    } else if (['Metadata', 'PortableRegistry'].includes(type)) {
+      metadataTypes[type] = true;
+    } else if ((codecClasses as Record<string, unknown>)[type]) {
+      codecTypes[type] = true;
+    } else if ((extrinsicClasses as Record<string, unknown>)[type]) {
+      extrinsicTypes[type] = true;
+    } else if ((genericClasses as Record<string, unknown>)[type]) {
+      genericTypes[type] = true;
+    } else if ((primitiveClasses as Record<string, unknown>)[type]) {
+      primitiveTypes[type] = true;
+    } else if (type.startsWith('[') && type.includes('|')) {
+      const splitTypes = splitAlternatives(type);
+      setImports(allDefs, imports, splitTypes);
+    } else if (type.includes('<') || type.includes('(') || type.includes('[')) {
+      // If the type is a bit special (tuple, fixed u8, nested type...), then we
+      // need to parse it with `getTypeDef`.
+      const typeDef = getTypeDef(type);
+      setImports(allDefs, imports, [TypeDefInfo[typeDef.info]]);
+      // TypeDef.sub is a `TypeDef | TypeDef[]`
+      if (Array.isArray(typeDef.sub)) {
+        typeDef.sub.forEach((subType) => setImports(allDefs, imports, [subType.lookupName || subType.type]));
+      } else if (typeDef.sub && (typeDef.info !== TypeDefInfo.VecFixed || typeDef.sub.type !== 'u8')) {
+        // typeDef.sub is a TypeDef in this case
+        setImports(allDefs, imports, [typeDef.sub.lookupName || typeDef.sub.type]);
+      }
+    } else {
+      // find this module inside the exports from the rest
+      const [moduleName] = Object.entries(allDefs).find(([, { types }]): boolean =>
+        Object.keys(types).includes(type)
+      ) || [null];
+      if (moduleName) {
+        localTypes[moduleName][type] = true;
+      }
+    }
+  });
+}
+// Create an Imports object, can be pre-filled with `ignoredTypes`
+/** @internal */
+export function createImports (importDefinitions: Record<string, Record<string, ModuleTypes>>, { types }: ModuleTypes = { types: {} }): TypeImports {
+  const definitions = {} as Record<string, ModuleTypes>;
+  const typeToModule = {} as Record<string, string>;
+  Object.entries(importDefinitions).forEach(([packagePath, packageDef]): void => {
+    Object.entries(packageDef).forEach(([name, moduleDef]): void => {
+      const fullName = `${packagePath}/${name}`;
+      definitions[fullName] = moduleDef;
+      Object.keys(moduleDef.types).forEach((type): void => {
+        if (typeToModule[type]) {
+          console.warn(`\t\tWARN: Overwriting duplicated type '${type}' ${typeToModule[type]} -> ${fullName}`);
+        }
+        typeToModule[type] = fullName;
+      });
+    });
+  });
+  return {
+    codecTypes: {},
+    definitions,
+    extrinsicTypes: {},
+    genericTypes: {},
+    ignoredTypes: Object.keys(types),
+    localTypes: Object.keys(definitions).reduce((local: Record<string, TypeExist>, mod): Record<string, TypeExist> => {
+      local[mod] = {};
+      return local;
+    }, {}),
+    lookupTypes: {},
+    metadataTypes: {},
+    primitiveTypes: {},
+    typeToModule,
+    typesTypes: {}
+  };
+}

package/src/util/index.ts ADDED Viewed

@@ -0,0 +1,18 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from './assert.js';
+export * from './derived.js';
+export * from './docs.js';
+export * from './file.js';
+export * from './formatting.js';
+export * from './imports.js';
+export * from './initMeta.js';
+export * from './register.js';
+export * from './wsMeta.js';
+interface Cmp { name: { toString(): string } }
+export function compareName (a: Cmp, b: Cmp): number {
+  return a.name.toString().localeCompare(b.name.toString());
+}

package/src/util/initMeta.ts ADDED Viewed

@@ -0,0 +1,37 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { HexString } from '@pezkuwi/util/types';
+import type { ExtraTypes } from '../generate/types.js';
+import { Metadata, TypeRegistry } from '@pezkuwi/types';
+import { registerDefinitions } from './register.js';
+interface Result {
+  metadata: Metadata;
+  registry: TypeRegistry;
+}
+/**
+ * This helper method has been transitioned to work with V14, V15 and up.
+ */
+export function initMeta (staticMeta: HexString, extraTypes: ExtraTypes = {}): Result {
+  const registry = new TypeRegistry();
+  registerDefinitions(registry, extraTypes);
+  let metadata: Metadata;
+  try {
+    const opaqueMetadata = registry.createType('Option<OpaqueMetadata>', registry.createType('Raw', staticMeta).toU8a()).unwrap();
+    metadata = new Metadata(registry, opaqueMetadata.toHex());
+  } catch {
+    metadata = new Metadata(registry, staticMeta);
+  }
+  registry.setMetadata(metadata);
+  return { metadata, registry };
+}

package/src/util/register.ts ADDED Viewed

@@ -0,0 +1,12 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { TypeRegistry } from '@pezkuwi/types/create';
+export function registerDefinitions (registry: TypeRegistry, extras: Record<string, Record<string, { types: Record<string, any> }>>): void {
+  Object.values(extras).forEach((def): void => {
+    Object.values(def).forEach(({ types }): void => {
+      registry.register(types);
+    });
+  });
+}

package/src/util/wsMeta.ts ADDED Viewed

@@ -0,0 +1,70 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { HexString } from '@pezkuwi/util/types';
+import { promiseTracker } from '@pezkuwi/api/promise/decorateMethod';
+import { TypeRegistry } from '@pezkuwi/types';
+import { stringify, u8aToHex } from '@pezkuwi/util';
+import { WebSocket } from '@pezkuwi/x-ws';
+async function getWsData <T> (endpoint: string, method: 'rpc_methods' | 'state_call' | 'state_getMetadata' | 'state_getRuntimeVersion', params?: string[]): Promise<T> {
+  return new Promise((resolve, reject): void => {
+    const tracker = promiseTracker<T>(resolve, reject);
+    try {
+      const websocket = new WebSocket(endpoint);
+      websocket.onclose = (event: { code: number; reason: string }): void => {
+        if (event.code !== 1000) {
+          tracker.reject(new Error(`disconnected, code: '${event.code}' reason: '${event.reason}'`));
+        }
+      };
+      websocket.onerror = (event: unknown): void => {
+        tracker.reject(new Error(`WebSocket error:: ${stringify(event)}`));
+      };
+      websocket.onopen = (): void => {
+        console.log('connected');
+        params
+          ? websocket.send(`{"id":"1","jsonrpc":"2.0","method":"${method}","params":[${params.map((param) => `"${param}"`).join(',')}]}`)
+          : websocket.send(`{"id":"1","jsonrpc":"2.0","method":"${method}","params":[]}`);
+      };
+      websocket.onmessage = (message: { data: string }): void => {
+        try {
+          tracker.resolve((JSON.parse(message.data) as { result: T }).result);
+        } catch (error) {
+          tracker.reject(error as Error);
+        }
+        websocket.close();
+      };
+    } catch (error) {
+      tracker.reject(error as Error);
+    }
+  });
+}
+export async function getMetadataViaWs (endpoint: string, metadataVer?: number): Promise<HexString> {
+  const registry = new TypeRegistry();
+  if (metadataVer) {
+    return await getWsData<HexString>(endpoint, 'state_call', ['Metadata_metadata_at_version', u8aToHex(registry.createType('u32', metadataVer).toU8a())]);
+  } else {
+    return await getWsData<HexString>(endpoint, 'state_getMetadata');
+  }
+}
+export async function getRpcMethodsViaWs (endpoint: string): Promise<string[]> {
+  const result = await getWsData<{ methods: string[] }>(endpoint, 'rpc_methods');
+  return result.methods;
+}
+export async function getRuntimeVersionViaWs (endpoint: string): Promise<[apiHash: string, apiVersion: number][]> {
+  const result = await getWsData<{ apis: [string, number][] }>(endpoint, 'state_getRuntimeVersion');
+  return result.apis;
+}

package/tsconfig.build.json ADDED Viewed

@@ -0,0 +1,28 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "scripts/**/*",
+    "**/*.spec.ts",
+    "**/mod.ts"
+  ],
+  "references": [
+    { "path": "../api/tsconfig.build.json" },
+    { "path": "../api-augment/tsconfig.build.json" },
+    { "path": "../api-derive/tsconfig.build.json" },
+    { "path": "../rpc-augment/tsconfig.build.json" },
+    { "path": "../rpc-provider/tsconfig.build.json" },
+    { "path": "../types/tsconfig.build.json" },
+    { "path": "../types-augment/tsconfig.build.json" },
+    { "path": "../types-codec/tsconfig.build.json" },
+    { "path": "../types-create/tsconfig.build.json" },
+    { "path": "../types-support/tsconfig.build.json" }
+  ]
+}