@pezkuwi/typegen 16.5.5 → 16.5.6

package/src/generate/lookup.ts

@@ -1,294 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { PortableType, SiLookupTypeId, SiPath, SiTypeParameter } from '@pezkuwi/types/interfaces';
-import type { PortableRegistry } from '@pezkuwi/types/metadata';
-import type { Registry } from '@pezkuwi/types/types';
-import type { TypeDef } from '@pezkuwi/types-create/types';
-import type { HexString } from '@pezkuwi/util/types';
-
-import Handlebars from 'handlebars';
-import path from 'node:path';
-
-import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
-import staticAhKusama from '@pezkuwi/types-support/metadata/v15/asset-hub-kusama-hex';
-import staticAhPolkadot from '@pezkuwi/types-support/metadata/v15/asset-hub-polkadot-hex';
-import staticKusama from '@pezkuwi/types-support/metadata/v15/kusama-hex';
-import staticPolkadot from '@pezkuwi/types-support/metadata/v15/polkadot-hex';
-import staticSubstrate from '@pezkuwi/types-support/metadata/v15/substrate-hex';
-import { isString, stringify } from '@pezkuwi/util';
-
-import { createImports, exportInterface, initMeta, readTemplate, type TypeImports, writeFile } from '../util/index.js';
-import { typeEncoders } from './tsDef.js';
-
-// Record<string, >
-interface ParsedDef {
-  _set: Record<string, number>;
-
-  [key: string]: string | Record<string, string> | Record<string, number>;
-}
-
-const WITH_TYPEDEF = false;
-
-const generateLookupDefsTmpl = Handlebars.compile(readTemplate('lookup/defs'));
-const generateLookupDefsNamedTmpl = Handlebars.compile(readTemplate('lookup/defs-named'));
-const generateLookupIndexTmpl = Handlebars.compile(readTemplate('lookup/index'));
-const generateLookupTypesTmpl = Handlebars.compile(readTemplate('lookup/types'));
-const generateRegistryTmpl = Handlebars.compile(readTemplate('interfaceRegistry'));
-
-function generateParamType (registry: Registry, { name, type }: SiTypeParameter): string {
-  if (type.isSome) {
-    const link = registry.lookup.types[type.unwrap().toNumber()];
-
-    if (link.type.path.length) {
-      return generateTypeDocs(registry, null, link.type.path, link.type.params);
-    }
-  }
-
-  return name.toString();
-}
-
-function generateTypeDocs (registry: Registry, id: SiLookupTypeId | null, path: SiPath, params: SiTypeParameter[]): string {
-  return `${id ? `${registry.createLookupType(id)}${path.length ? ': ' : ''}` : ''}${path.map((p) => p.toString()).join('::')}${params.length ? `<${params.map((p) => generateParamType(registry, p)).join(', ')}>` : ''}`;
-}
-
-function formatObject (lines: string[]): string[] {
-  const max = lines.length - 1;
-
-  return [
-    '{',
-    ...lines.map((l, index) =>
-      (l.endsWith(',') || l.endsWith('{') || index === max || lines[index + 1].endsWith('}') || lines[index + 1].endsWith('}'))
-        ? l
-        : `${l},`
-    ),
-    '}'
-  ];
-}
-
-function expandSet (parsed: Record<string, number>): string[] {
-  return formatObject(
-    Object.entries(parsed).reduce<string[]>((all, [k, v]) => {
-      all.push(`${k}: ${v}`);
-
-      return all;
-    }, [])
-  );
-}
-
-function expandObject (parsed: ParsedDef): string[] {
-  if (parsed._set) {
-    return expandSet(parsed._set);
-  }
-
-  return formatObject(
-    Object.entries(parsed).reduce<string[]>((all, [k, v]) => {
-      const inner = isString(v)
-        ? expandType(v)
-        : Array.isArray(v)
-          ? [`[${(v as string[]).map((e) => `'${e}'`).join(', ')}]`]
-          : expandObject(v as ParsedDef);
-
-      inner.forEach((l, index): void => {
-        all.push(`${
-          index === 0
-            ? `${k}: ${l}`
-            : `${l}`
-        }`);
-      });
-
-      return all;
-    }, [])
-  );
-}
-
-function expandType (encoded: string): string[] {
-  if (!encoded.startsWith('{')) {
-    return [`'${encoded}'`];
-  }
-
-  return expandObject(JSON.parse(encoded) as ParsedDef);
-}
-
-function expandDefToString ({ lookupNameRoot, type }: TypeDef, indent: number): string {
-  if (lookupNameRoot) {
-    return `'${lookupNameRoot}'`;
-  }
-
-  const lines = expandType(type);
-  let inc = 0;
-
-  return lines.map((l, index) => {
-    let r: string;
-
-    if (l.endsWith('{')) {
-      r = index === 0
-        ? l
-        : `${' '.padStart(indent + inc)}${l}`;
-      inc += 2;
-    } else {
-      if (l.endsWith('},') || l.endsWith('}')) {
-        inc -= 2;
-      }
-
-      r = index === 0
-        ? l
-        : `${' '.padStart(indent + inc)}${l}`;
-    }
-
-    return r;
-  }).join('\n');
-}
-
-function getFilteredTypes (lookup: PortableRegistry, exclude: string[] = []): [PortableType, TypeDef][] {
-  const named = lookup.types.filter(({ id }) => !!lookup.getTypeDef(id).lookupName);
-  const names = named.map(({ id }) => lookup.getName(id));
-
-  return named
-    .filter((_, index) =>
-      !names.some((n, iindex) =>
-        index > iindex &&
-        n === names[index]
-      )
-    )
-    .map((p): [PortableType, TypeDef] => [p, lookup.getTypeDef(p.id)])
-    .filter(([, typeDef]) => !exclude.includes(typeDef.lookupName || '<invalid>'));
-}
-
-function generateLookupDefs (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath?: string): void {
-  writeFile(path.join(destDir, `${subPath || 'definitions'}.ts`), (): string => {
-    const all = filtered.map(([{ id, type: { params, path } }, typeDef]) => {
-      const typeLookup = registry.createLookupType(id);
-      const def = expandDefToString(typeDef, subPath ? 2 : 4);
-
-      return {
-        docs: [
-          generateTypeDocs(registry, id, path, params),
-          WITH_TYPEDEF
-            ? `@typeDef ${stringify(typeDef)}`
-            : null
-        ].filter((d): d is string => !!d),
-        type: { def, typeLookup, typeName: typeDef.lookupName }
-      };
-    });
-    const max = all.length - 1;
-
-    return (subPath ? generateLookupDefsNamedTmpl : generateLookupDefsTmpl)({
-      defs: all.map(({ docs, type }, i) => {
-        const { def, typeLookup, typeName } = type;
-
-        return {
-          defs: [
-            [typeName || typeLookup, `${def}${i !== max ? ',' : ''}`]
-          ].map(([n, t]) => `${n}: ${t}`),
-          docs
-        };
-      }),
-      headerType: 'defs'
-    });
-  });
-}
-
-function generateLookupTypes (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath?: string): void {
-  const imports = {
-    ...createImports(
-      { '@pezkuwi/types/interfaces': defaultDefinitions },
-      { types: {} }
-    ),
-    interfaces: []
-  };
-  const items = filtered
-    .map(([, typeDef]) => {
-      typeDef.name = typeDef.lookupName;
-
-      return typeDef.lookupNameRoot && typeDef.lookupName
-        ? exportInterface(typeDef.lookupIndex, typeDef.lookupName, typeDef.lookupNameRoot)
-        : typeEncoders[typeDef.info](registry, imports.definitions, typeDef, imports);
-    })
-    .filter((t): t is string => !!t)
-    .map((t) => t.replace(/\nexport /, '\n'));
-
-  writeFile(path.join(destDir, `types${subPath ? `-${subPath}` : ''}.ts`), () => generateLookupTypesTmpl({
-    headerType: 'defs',
-    imports,
-    items: items.map((l) =>
-      l
-        .split('\n')
-        .map((l) => l.length ? `  ${l}` : '')
-        .join('\n')
-    ),
-    types: [
-      ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
-        file: packagePath,
-        types: Object.keys(imports.localTypes[packagePath])
-      }))
-    ]
-  }), true);
-  writeFile(path.join(destDir, 'index.ts'), () => generateLookupIndexTmpl({ headerType: 'defs' }), true);
-}
-
-function generateRegistry (_registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath: string): void {
-  writeFile(path.join(destDir, `${subPath}.ts`), (): string => {
-    const items = filtered
-      .map(([, { lookupName }]) => lookupName)
-      .filter((n): n is string => !!n)
-      .sort()
-      .reduce((all: string[], n) => all.includes(n) ? all : all.concat(n), []);
-    const imports = createImports({}, { types: {} });
-
-    imports.lookupTypes = items.reduce((all, n) => ({ ...all, [n]: true }), {});
-
-    return generateRegistryTmpl({
-      headerType: 'defs',
-      imports,
-      items,
-      types: []
-    });
-  }, true);
-}
-
-function generateLookup (destDir: string, entries: [string, HexString][]): void {
-  entries.reduce<string[]>((exclude, [subPath, staticMeta]): string[] => {
-    const { lookup, registry } = initMeta(staticMeta).metadata.asLatest;
-    const filtered = getFilteredTypes(lookup, exclude);
-
-    generateLookupDefs(registry, filtered, destDir, subPath);
-    generateLookupTypes(registry, filtered, destDir, subPath);
-    generateRegistry(registry, filtered, destDir, subPath === 'lookup' ? 'registry' : `../registry/${subPath}`);
-
-    return exclude.concat(
-      ...filtered
-        .map(([, typeDef]) => typeDef.lookupName)
-        .filter((n): n is string => !!n)
-    );
-  }, []);
-}
-
-// Generate `packages/types/src/lookup/*s`, the registry of all lookup types
-export function generateDefaultLookup (destDir = 'packages/types-augment/src/lookup', staticData?: HexString): void {
-  generateLookup(
-    destDir,
-    staticData
-      ? [['lookup', staticData]]
-      : [
-        ['substrate', staticSubstrate],
-        ['polkadot', staticPolkadot],
-        ['kusama', staticKusama],
-        ['assetHubPolkadot', staticAhPolkadot],
-        ['assetHubKusama', staticAhKusama]
-      ]
-  );
-}
-
-// Based on a list of types, it filters out the lookup types that are not needed.
-export function ignoreUnusedLookups (usedTypes: string[], imports: TypeImports) {
-  const usedStringified = usedTypes.toString();
-
-  const [lookupKey, typeDefinitions] = Object.entries(imports.localTypes).find(([typeModule, _]) => typeModule.includes('/lookup')) || ['', {}];
-
-  Object.keys(typeDefinitions).forEach((typeDef) => {
-    if (!(usedStringified.includes(typeDef))) {
-      delete (imports.localTypes[lookupKey])[typeDef];
-    }
-  });
-}

package/src/generate/query.ts

@@ -1,169 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { StorageEntryMetadataLatest } from '@pezkuwi/types/interfaces';
-import type { Metadata, PortableRegistry } from '@pezkuwi/types/metadata';
-import type { Definitions, Registry } from '@pezkuwi/types/types';
-import type { HexString } from '@pezkuwi/util/types';
-import type { ModuleTypes, TypeImports } from '../util/imports.js';
-
-import Handlebars from 'handlebars';
-
-import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
-import { unwrapStorageSi } from '@pezkuwi/types/util';
-import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
-import { stringCamelCase } from '@pezkuwi/util';
-
-import { compareName, createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
-import { ignoreUnusedLookups } from './lookup.js';
-import { type ExtraTypes, getDeprecationNotice } from './types.js';
-
-const generateForMetaTemplate = Handlebars.compile(readTemplate('query'));
-
-// From a storage entry metadata, we return [args, returnType]
-/** @internal */
-function entrySignature (lookup: PortableRegistry, allDefs: Record<string, ModuleTypes>, registry: Registry, section: string, storageEntry: StorageEntryMetadataLatest, imports: TypeImports): [boolean, string, string, string] {
-  try {
-    const outputType = lookup.getTypeDef(unwrapStorageSi(storageEntry.type));
-
-    if (storageEntry.type.isPlain) {
-      const typeDef = lookup.getTypeDef(storageEntry.type.asPlain);
-
-      setImports(allDefs, imports, [
-        typeDef.lookupName || typeDef.type,
-        storageEntry.modifier.isOptional
-          ? 'Option'
-          : null
-      ]);
-
-      return [storageEntry.modifier.isOptional, '', '', formatType(registry, allDefs, outputType, imports)];
-    } else if (storageEntry.type.isMap) {
-      const { hashers, key, value } = storageEntry.type.asMap;
-      const keyDefs = hashers.length === 1
-        ? [lookup.getTypeDef(key)]
-        : lookup.getSiType(key).def.asTuple.map((k) => lookup.getTypeDef(k));
-      const similarTypes = keyDefs.map((k) => getSimilarTypes(registry, allDefs, k.lookupName || k.type, imports));
-      const keyTypes = similarTypes.map((t) => t.join(' | '));
-      const defValue = lookup.getTypeDef(value);
-
-      setImports(allDefs, imports, [
-        ...similarTypes.reduce<string[]>((all, t) => all.concat(t), []),
-        storageEntry.modifier.isOptional
-          ? 'Option'
-          : null,
-        defValue.lookupName || defValue.type
-      ]);
-
-      return [
-        storageEntry.modifier.isOptional,
-        keyDefs.map((k) => formatType(registry, allDefs, k.lookupName || k.type, imports)).join(', '),
-        keyTypes.map((t, i) => `arg${keyTypes.length === 1 ? '' : (i + 1)}: ${t}`).join(', '),
-        outputType.lookupName || formatType(registry, allDefs, outputType, imports)
-      ];
-    }
-
-    throw new Error(`Expected Plain or Map type, found ${storageEntry.type.type}`);
-  } catch (error) {
-    throw new Error(`entrySignature: Cannot create signature for query ${section}.${storageEntry.name.toString()}:: ${(error as Error).message}`);
-  }
-}
-
-/** @internal */
-function generateForMeta (registry: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
-  writeFile(dest, (): string => {
-    const allTypes: ExtraTypes = {
-      '@pezkuwi/types-augment': {
-        lookup: {
-          ...lookupDefinitions,
-          ...customLookupDefinitions
-        }
-      },
-      '@pezkuwi/types/interfaces': defaultDefs,
-      ...extraTypes
-    };
-
-    const imports = createImports(allTypes);
-    const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
-      return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
-    }, {});
-    const { lookup, pallets } = meta.asLatest;
-    const usedTypes = new Set<string>([]);
-    const modules = pallets
-      .filter(({ storage }) => storage.isSome)
-      .map(({ name, storage }) => {
-        const items = storage.unwrap().items
-          .map((storageEntry) => {
-            const { deprecationInfo, docs, name } = storageEntry;
-            const [isOptional, args, params, _returnType] = entrySignature(lookup, allDefs, registry, name.toString(), storageEntry, imports);
-
-            if (!deprecationInfo.isNotDeprecated) {
-              const deprecationNotice = getDeprecationNotice(deprecationInfo, stringCamelCase(name));
-              const items = docs.length
-                ? ['', deprecationNotice]
-                : [deprecationNotice];
-
-              docs.push(...items.map((text) => registry.createType('Text', text)));
-            }
-
-            // Add the type and args to the list of used types
-            if (!(imports.primitiveTypes[_returnType])) {
-              usedTypes.add(_returnType);
-            }
-
-            if (!(imports.primitiveTypes[args])) {
-              usedTypes.add(args);
-            }
-
-            const returnType = isOptional
-              ? `Option<${_returnType}>`
-              : _returnType;
-
-            return {
-              args,
-              docs,
-              entryType: 'AugmentedQuery',
-              name: stringCamelCase(storageEntry.name),
-              params,
-              returnType
-            };
-          })
-          .sort(compareName);
-
-        return {
-          items,
-          name: stringCamelCase(name)
-        };
-      })
-      .sort(compareName);
-
-    imports.typesTypes['Observable'] = true;
-
-    // filter out the unused lookup types from imports
-    ignoreUnusedLookups([...usedTypes], imports);
-
-    return generateForMetaTemplate({
-      headerType: 'chain',
-      imports,
-      isStrict,
-      modules,
-      types: [
-        ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
-          file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-          types: Object.keys(imports.localTypes[packagePath])
-        })),
-        {
-          file: '@pezkuwi/api-base/types',
-          types: ['ApiTypes', 'AugmentedQuery', 'QueryableStorageEntry']
-        }
-      ]
-    });
-  });
-}
-
-// Call `generateForMeta()` with current static metadata
-/** @internal */
-export function generateDefaultQuery (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
-  const { metadata, registry } = initMeta(data, extraTypes);
-
-  return generateForMeta(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

package/src/generate/rpc.ts

@@ -1,158 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { TypeRegistry } from '@pezkuwi/types/create';
-import type { Definitions } from '@pezkuwi/types/types';
-import type { ExtraTypes } from './types.js';
-
-import Handlebars from 'handlebars';
-
-import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
-import staticSubstrate from '@pezkuwi/types-support/metadata/static-substrate';
-
-import { createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
-
-interface ItemDef {
-  args: string;
-  docs: string[];
-  generic: string | undefined;
-  name: string;
-  type: string | undefined;
-}
-
-interface ModuleDef {
-  items: ItemDef[];
-  name: string;
-}
-
-const StorageKeyType = 'StorageKey | string | Uint8Array | any';
-
-const generateRpcTypesTemplate = Handlebars.compile(readTemplate('rpc'));
-
-/** @internal */
-export function generateRpcTypes (registry: TypeRegistry, importDefinitions: Record<string, Definitions>, dest: string, extraTypes: ExtraTypes): void {
-  writeFile(dest, (): string => {
-    const allTypes: ExtraTypes = { '@pezkuwi/types/interfaces': importDefinitions, ...extraTypes };
-    const imports = createImports(allTypes);
-    const definitions = imports.definitions as Record<string, Definitions>;
-    const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
-      return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
-    }, {});
-
-    const rpcKeys = Object
-      .keys(definitions)
-      .filter((key) => Object.keys(definitions[key].rpc || {}).length !== 0)
-      .sort();
-
-    const additional: Record<string, ModuleDef> = {};
-    const modules = rpcKeys.map((sectionFullName) => {
-      const rpc = definitions[sectionFullName].rpc || {};
-      const section = sectionFullName.split('/').pop();
-
-      const allMethods = Object.keys(rpc).sort().map((methodName) => {
-        const def = rpc[methodName];
-
-        let args;
-        let type;
-        let generic;
-
-        // These are too hard to type with generics, do manual overrides
-        if (section === 'state') {
-          setImports(allDefs, imports, ['Codec', 'Hash', 'StorageKey', 'Vec']);
-
-          if (methodName === 'getStorage') {
-            generic = 'T = Codec';
-            args = [`key: ${StorageKeyType}, block?: Hash | Uint8Array | string`];
-            type = 'T';
-          } else if (methodName === 'queryStorage') {
-            generic = 'T = Codec[]';
-            args = [`keys: Vec<StorageKey> | (${StorageKeyType})[], fromBlock?: Hash | Uint8Array | string, toBlock?: Hash | Uint8Array | string`];
-            type = '[Hash, T][]';
-          } else if (methodName === 'queryStorageAt') {
-            generic = 'T = Codec[]';
-            args = [`keys: Vec<StorageKey> | (${StorageKeyType})[], at?: Hash | Uint8Array | string`];
-            type = 'T';
-          } else if (methodName === 'subscribeStorage') {
-            generic = 'T = Codec[]';
-            args = [`keys?: Vec<StorageKey> | (${StorageKeyType})[]`];
-            type = 'T';
-          }
-        }
-
-        if (args === undefined) {
-          setImports(allDefs, imports, [def.type]);
-
-          args = def.params.map((param) => {
-            const similarTypes = getSimilarTypes(registry, definitions, param.type, imports);
-
-            setImports(allDefs, imports, [param.type, ...similarTypes]);
-
-            return `${param.name}${param.isOptional ? '?' : ''}: ${similarTypes.join(' | ')}`;
-          });
-
-          type = formatType(registry, allDefs, def.type, imports);
-          generic = '';
-        }
-
-        const item = {
-          args: args.join(', '),
-          docs: def.deprecated
-            ? [`@deprecated ${def.deprecated}`, def.description]
-            : [def.description],
-          generic,
-          name: methodName,
-          type
-        };
-
-        if (def.aliasSection) {
-          if (!additional[def.aliasSection]) {
-            additional[def.aliasSection] = {
-              items: [],
-              name: def.aliasSection
-            };
-          }
-
-          additional[def.aliasSection].items.push(item);
-
-          return null;
-        }
-
-        return item;
-      }).filter((item): item is ItemDef => !!item);
-
-      return {
-        items: allMethods,
-        name: section || 'unknown'
-      };
-    }).concat(...Object.values(additional)).sort((a, b) => a.name.localeCompare(b.name));
-
-    imports.typesTypes['Observable'] = true;
-
-    return generateRpcTypesTemplate({
-      headerType: 'chain',
-      imports,
-      modules,
-      types: [
-        ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
-          file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-          types: Object.keys(imports.localTypes[packagePath])
-        })),
-        {
-          file: '@pezkuwi/rpc-core/types',
-          types: ['AugmentedRpc']
-        }
-      ]
-    });
-  });
-}
-
-export function generateDefaultRpc (dest = 'packages/rpc-augment/src/augment/jsonrpc.ts', extraTypes: ExtraTypes = {}): void {
-  const { registry } = initMeta(staticSubstrate, extraTypes);
-
-  generateRpcTypes(
-    registry,
-    defaultDefinitions,
-    dest,
-    extraTypes
-  );
-}