@pezkuwi/typegen 16.5.5 → 16.5.6

package/src/generate/consts.ts

@@ -1,112 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
-import type { Definitions } from '@pezkuwi/types/types';
-import type { HexString } from '@pezkuwi/util/types';
-
-import Handlebars from 'handlebars';
-
-import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
-import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
-import { stringCamelCase } from '@pezkuwi/util';
-
-import { compareName, createImports, formatType, 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('consts'));
-
-/** @internal */
-function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
-  writeFile(dest, (): string => {
-    const allTypes = {
-      '@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, registry } = meta.asLatest;
-    const usedTypes = new Set<string>([]);
-
-    const modules = pallets
-      .filter(({ constants }) => constants.length > 0)
-      .map(({ constants, name }) => {
-        if (!isStrict) {
-          setImports(allDefs, imports, ['Codec']);
-        }
-
-        const items = constants
-          .map(({ deprecationInfo, docs, name, type }) => {
-            const typeDef = lookup.getTypeDef(type);
-            const returnType = typeDef.lookupName || formatType(registry, allDefs, typeDef, imports);
-
-            if (!deprecationInfo.isNotDeprecated) {
-              const deprecationNotice = getDeprecationNotice(deprecationInfo, stringCamelCase(name), 'Constant');
-
-              const items = docs.length
-                ? ['', deprecationNotice]
-                : [deprecationNotice];
-
-              docs.push(...items.map((text) => registry.createType('Text', text)));
-            }
-
-            // Add the type to the list of used types
-            if (!(imports.primitiveTypes[returnType])) {
-              usedTypes.add(returnType);
-            }
-
-            setImports(allDefs, imports, [returnType]);
-
-            return {
-              docs,
-              name: stringCamelCase(name),
-              type: returnType
-            };
-          })
-          .sort(compareName);
-
-        return {
-          items,
-          name: stringCamelCase(name)
-        };
-      })
-      .sort(compareName);
-
-    // 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<{ file: string; types: string[] }>((packagePath) => ({
-          file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-          types: Object.keys(imports.localTypes[packagePath])
-        })),
-        {
-          file: '@pezkuwi/api-base/types',
-          types: ['ApiTypes', 'AugmentedConst']
-        }
-      ]
-    });
-  });
-}
-
-// Call `generateForMeta()` with current static metadata
-/** @internal */
-export function generateDefaultConsts (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
-  const { metadata } = initMeta(data, extraTypes);
-
-  return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

package/src/generate/errors.ts

@@ -1,75 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { VariantDeprecationInfoV16 } from '@pezkuwi/types/interfaces';
-import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
-import type { HexString } from '@pezkuwi/util/types';
-
-import Handlebars from 'handlebars';
-
-import { stringCamelCase } from '@pezkuwi/util';
-
-import { compareName, createImports, initMeta, readTemplate, writeFile } from '../util/index.js';
-import { type ExtraTypes, getDeprecationNotice } from './types.js';
-
-const generateForMetaTemplate = Handlebars.compile(readTemplate('errors'));
-
-/** @internal */
-function generateForMeta (meta: Metadata, dest: string, isStrict: boolean): void {
-  writeFile(dest, (): string => {
-    const imports = createImports({});
-    const { lookup, pallets } = meta.asLatest;
-    const modules = pallets
-      .filter(({ errors }) => errors.isSome)
-      .map((data) => {
-        const name = data.name;
-        const errors = data.errors.unwrap();
-        const deprecationInfo = errors.deprecationInfo.toJSON();
-
-        return {
-          items: lookup.getSiType(errors.type).def.asVariant.variants
-            .map(({ docs, index, name }) => {
-              const rawStatus = deprecationInfo?.[index.toNumber()];
-
-              if (rawStatus) {
-                const deprecationVariantInfo: VariantDeprecationInfoV16 = meta.registry.createTypeUnsafe('VariantDeprecationInfoV16', [rawStatus]);
-
-                const deprecationNotice = getDeprecationNotice(deprecationVariantInfo, name.toString());
-                const notice = docs.length ? ['', deprecationNotice] : [deprecationNotice];
-
-                docs.push(...notice.map((text) => meta.registry.createType('Text', text)));
-              }
-
-              return {
-                docs,
-                name: name.toString()
-              };
-            })
-            .sort(compareName),
-          name: stringCamelCase(name)
-        };
-      })
-      .sort(compareName);
-
-    return generateForMetaTemplate({
-      headerType: 'chain',
-      imports,
-      isStrict,
-      modules,
-      types: [
-        {
-          file: '@pezkuwi/api-base/types',
-          types: ['ApiTypes', 'AugmentedError']
-        }
-      ]
-    });
-  });
-}
-
-// Call `generateForMeta()` with current static metadata
-/** @internal */
-export function generateDefaultErrors (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false): void {
-  const { metadata } = initMeta(data, extraTypes);
-
-  return generateForMeta(metadata, dest, isStrict);
-}

package/src/generate/events.ts

@@ -1,165 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { VariantDeprecationInfoV16 } from '@pezkuwi/types/interfaces';
-import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
-import type { Definitions } from '@pezkuwi/types/types';
-import type { HexString } from '@pezkuwi/util/types';
-
-import Handlebars from 'handlebars';
-
-import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
-import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
-import { stringCamelCase } from '@pezkuwi/util';
-
-import { compareName, createImports, formatType, 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('events'));
-
-// For babel itself we need some extra aliasing
-// Also avoid reserved words to prevent generating invalid TS
-// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#reserved_words
-const ALIAS = [
-  'symbol',
-  'break',
-  'case',
-  'catch',
-  'class',
-  'const',
-  'continue',
-  'debugger',
-  'default',
-  'delete',
-  'do',
-  'else',
-  'export',
-  'extends',
-  'false',
-  'finally',
-  'for',
-  'function',
-  'if',
-  'import',
-  'in',
-  'instanceof',
-  'new',
-  'null',
-  'return',
-  'static',
-  'super',
-  'switch',
-  'this',
-  'throw',
-  'true',
-  'try',
-  'typeof',
-  'var',
-  'void',
-  'while',
-  'with',
-  'yield'
-];
-
-/** @internal */
-function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
-  writeFile(dest, (): string => {
-    const allTypes = {
-      '@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, registry } = meta.asLatest;
-    const usedTypes = new Set<string>([]);
-    const modules = pallets
-      .filter(({ events }) => events.isSome)
-      .map((data) => {
-        const name = data.name;
-        const events = data.events.unwrap();
-        const deprecationInfo = events.deprecationInfo.toJSON();
-
-        return {
-          items: lookup.getSiType(events.type).def.asVariant.variants
-            .map(({ docs, fields, index, name }) => {
-              const rawStatus = deprecationInfo?.[index.toNumber()];
-
-              if (rawStatus) {
-                const deprecationVariantInfo: VariantDeprecationInfoV16 = meta.registry.createTypeUnsafe('VariantDeprecationInfoV16', [rawStatus]);
-                const deprecationNotice = getDeprecationNotice(deprecationVariantInfo, name.toString());
-                const notice = docs.length ? ['', deprecationNotice] : [deprecationNotice];
-
-                docs.push(...notice.map((text) => meta.registry.createType('Text', text)));
-              }
-
-              const args = fields
-                .map(({ type }) => lookup.getTypeDef(type))
-                .map((typeDef) => {
-                  const arg = typeDef.lookupName || formatType(registry, allDefs, typeDef, imports);
-
-                  // Add the type to the list of used types
-                  if (!(imports.primitiveTypes[arg])) {
-                    usedTypes.add(arg);
-                  }
-
-                  return arg;
-                });
-
-              const names = fields
-                .map(({ name }) => registry.lookup.sanitizeField(name)[0])
-                .filter((n): n is string => !!n);
-
-              setImports(allDefs, imports, args);
-
-              return {
-                docs,
-                name: name.toString(),
-                type: names.length !== 0 && names.length === args.length
-                  ? `[${names.map((n, i) => `${ALIAS.includes(n) ? `${n}_` : n}: ${args[i]}`).join(', ')}], { ${names.map((n, i) => `${n}: ${args[i]}`).join(', ')} }`
-                  : `[${args.join(', ')}]`
-              };
-            })
-            .sort(compareName),
-          name: stringCamelCase(name)
-        };
-      })
-      .sort(compareName);
-
-    // 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', 'AugmentedEvent']
-        }
-      ]
-    });
-  });
-}
-
-// Call `generateForMeta()` with current static metadata
-/** @internal */
-export function generateDefaultEvents (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
-  const { metadata } = initMeta(data, extraTypes);
-
-  return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

package/src/generate/interfaceRegistry.ts

@@ -1,85 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { ModuleTypes } from '../util/imports.js';
-
-import Handlebars from 'handlebars';
-
-import { Json, Raw } from '@pezkuwi/types/codec';
-import { TypeRegistry } from '@pezkuwi/types/create';
-import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
-import * as defaultPrimitives from '@pezkuwi/types/primitive';
-
-import { createImports, readTemplate, setImports, writeFile } from '../util/index.js';
-
-const primitiveClasses = {
-  ...defaultPrimitives,
-  Json,
-  Raw
-};
-
-const generateInterfaceTypesTemplate = Handlebars.compile(readTemplate('interfaceRegistry'));
-
-/** @internal */
-export function generateInterfaceTypes (importDefinitions: Record<string, Record<string, ModuleTypes>>, dest: string): void {
-  const registry = new TypeRegistry();
-
-  writeFile(dest, (): string => {
-    Object.entries(importDefinitions).reduce((acc, def) => Object.assign(acc, def), {});
-
-    const imports = createImports(importDefinitions);
-    const definitions = imports.definitions;
-    const items: string[] = [];
-
-    // first we create imports for our known classes from the API
-    Object
-      .keys(primitiveClasses)
-      .filter((name) => !name.includes('Generic'))
-      .forEach((primitiveName): void => {
-        setImports(definitions, imports, [primitiveName]);
-
-        items.push(primitiveName);
-      });
-
-    const existingTypes: Record<string, boolean> = {};
-
-    // ensure we have everything registered since we will get the definition
-    // form the available types (so any unknown should show after this)
-    Object.values(definitions).forEach(({ types }) => {
-      registry.register(types as Record<string, string>);
-    });
-
-    // create imports for everything that we have available
-    Object.values(definitions).forEach(({ types }) => {
-      setImports(definitions, imports, Object.keys(types));
-
-      const uniqueTypes = Object.keys(types).filter((type) => !existingTypes[type]);
-
-      uniqueTypes.forEach((type): void => {
-        existingTypes[type] = true;
-
-        items.push(type);
-      });
-    });
-
-    return generateInterfaceTypesTemplate({
-      headerType: 'defs',
-      imports,
-      items: items.sort((a, b) => a.localeCompare(b)),
-      types: [
-        ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
-          file: packagePath,
-          types: Object.keys(imports.localTypes[packagePath])
-        }))
-      ]
-    });
-  });
-}
-
-// Generate `packages/types/src/interfaceRegistry.ts`, the registry of all interfaces
-export function generateDefaultInterface (): void {
-  generateInterfaceTypes(
-    { '@pezkuwi/types/interfaces': defaultDefinitions },
-    'packages/types-augment/src/registry/interfaces.ts'
-  );
-}