Rename sizeNodes to countNodes

.changeset/eight-numbers-admire.md

@@ -0,0 +1,5 @@
+---
+"@metaplex-foundation/kinobi": minor
+---
+
+Rename sizeNodes to countNodes

src/nodes/Node.ts

@@ -14,7 +14,7 @@ import { REGISTERED_CONTEXTUAL_VALUE_NODES } from './contextualValueNodes/Contex
 import { REGISTERED_DISCRIMINATOR_NODES } from './discriminatorNodes/DiscriminatorNode';
 import { REGISTERED_LINK_NODES } from './linkNodes/LinkNode';
 import { REGISTERED_PDA_SEED_NODES } from './pdaSeedNodes/PdaSeedNode';
-import { REGISTERED_SIZE_NODES } from './sizeNodes/SizeNode';
+import { REGISTERED_COUNT_NODES } from './countNodes/CountNode';
 import { REGISTERED_TYPE_NODES } from './typeNodes/TypeNode';
 import { REGISTERED_VALUE_NODES } from './valueNodes/ValueNode';
 
@@ -38,7 +38,7 @@ const REGISTERED_NODES = {
   ...REGISTERED_DISCRIMINATOR_NODES,
   ...REGISTERED_LINK_NODES,
   ...REGISTERED_PDA_SEED_NODES,
-  ...REGISTERED_SIZE_NODES,
+  ...REGISTERED_COUNT_NODES,
   ...REGISTERED_TYPE_NODES,
   ...REGISTERED_VALUE_NODES,
 };

src/nodes/countNodes/CountNode.ts

@@ -0,0 +1,23 @@
+import { getNodeKinds } from '../../shared/utils';
+import type { FixedCountNode } from './FixedCountNode';
+import type { PrefixedCountNode } from './PrefixedCountNode';
+import type { RemainderCountNode } from './RemainderCountNode';
+
+// Count Node Registration.
+
+export const REGISTERED_COUNT_NODES = {
+  fixedCountNode: {} as FixedCountNode,
+  remainderCountNode: {} as RemainderCountNode,
+  prefixedCountNode: {} as PrefixedCountNode,
+};
+
+export const REGISTERED_COUNT_NODE_KINDS = getNodeKinds(REGISTERED_COUNT_NODES);
+export type RegisteredCountNodeKind =
+  (typeof REGISTERED_COUNT_NODE_KINDS)[number];
+export type RegisteredCountNode =
+  (typeof REGISTERED_COUNT_NODES)[RegisteredCountNodeKind];
+
+// Count Node Helpers.
+
+export type CountNode = RegisteredCountNode;
+export const COUNT_NODES = REGISTERED_COUNT_NODE_KINDS;

src/nodes/countNodes/FixedCountNode.ts

@@ -0,0 +1,10 @@
+export type FixedCountNode = {
+  readonly kind: 'fixedCountNode';
+
+  // Data.
+  readonly value: number;
+};
+
+export function fixedCountNode(value: number): FixedCountNode {
+  return { kind: 'fixedCountNode', value };
+}

src/nodes/countNodes/PrefixedCountNode.ts

@@ -0,0 +1,12 @@
+import { NumberTypeNode } from '../typeNodes';
+
+export type PrefixedCountNode = {
+  readonly kind: 'prefixedCountNode';
+
+  // Children.
+  readonly prefix: NumberTypeNode;
+};
+
+export function prefixedCountNode(prefix: NumberTypeNode): PrefixedCountNode {
+  return { kind: 'prefixedCountNode', prefix };
+}

src/nodes/countNodes/RemainderCountNode.ts

@@ -0,0 +1,7 @@
+export type RemainderCountNode = {
+  readonly kind: 'remainderCountNode';
+};
+
+export function remainderCountNode(): RemainderCountNode {
+  return { kind: 'remainderCountNode' };
+}

src/nodes/countNodes/index.ts

@@ -0,0 +1,4 @@
+export * from './CountNode';
+export * from './FixedCountNode';
+export * from './PrefixedCountNode';
+export * from './RemainderCountNode';

src/nodes/index.ts

@@ -12,9 +12,9 @@ export * from './ProgramNode';
 export * from './RootNode';
 
 export * from './contextualValueNodes';
+export * from './countNodes';
 export * from './discriminatorNodes';
 export * from './linkNodes';
 export * from './pdaSeedNodes';
-export * from './sizeNodes';
 export * from './typeNodes';
 export * from './valueNodes';

src/nodes/typeNodes/ArrayTypeNode.ts

@@ -1,10 +1,10 @@
 import type { IdlTypeArray, IdlTypeVec } from '../../idl';
 import {
-  SizeNode,
-  fixedSizeNode,
-  prefixedSizeNode,
-  remainderSizeNode,
-} from '../sizeNodes';
+  CountNode,
+  fixedCountNode,
+  prefixedCountNode,
+  remainderCountNode,
+} from '../countNodes';
 import { numberTypeNode } from './NumberTypeNode';
 import { TypeNode, createTypeNodeFromIdl } from './TypeNode';
 
@@ -13,14 +13,17 @@ export type ArrayTypeNode = {
 
   // Children.
   readonly item: TypeNode;
-  readonly size: SizeNode;
+  readonly count: CountNode;
 };
 
-export function arrayTypeNode(item: TypeNode, size?: SizeNode): ArrayTypeNode {
+export function arrayTypeNode(
+  item: TypeNode,
+  count?: CountNode
+): ArrayTypeNode {
   return {
     kind: 'arrayTypeNode',
     item,
-    size: size ?? prefixedSizeNode(numberTypeNode('u32')),
+    count: count ?? prefixedCountNode(numberTypeNode('u32')),
   };
 }
 
@@ -29,10 +32,11 @@ export function arrayTypeNodeFromIdl(
 ): ArrayTypeNode {
   if ('array' in idl) {
     const item = createTypeNodeFromIdl(idl.array[0]);
-    return arrayTypeNode(item, fixedSizeNode(idl.array[1]));
+    return arrayTypeNode(item, fixedCountNode(idl.array[1]));
   }
   const item = createTypeNodeFromIdl(idl.vec);
   if (!idl.size) return arrayTypeNode(item);
-  if (idl.size === 'remainder') return arrayTypeNode(item, remainderSizeNode());
-  return arrayTypeNode(item, prefixedSizeNode(numberTypeNode(idl.size)));
+  if (idl.size === 'remainder')
+    return arrayTypeNode(item, remainderCountNode());
+  return arrayTypeNode(item, prefixedCountNode(numberTypeNode(idl.size)));
 }

src/nodes/typeNodes/MapTypeNode.ts

@@ -1,10 +1,10 @@
 import type { IdlTypeMap } from '../../idl';
 import {
-  SizeNode,
-  fixedSizeNode,
-  prefixedSizeNode,
-  remainderSizeNode,
-} from '../sizeNodes';
+  CountNode,
+  fixedCountNode,
+  prefixedCountNode,
+  remainderCountNode,
+} from '../countNodes';
 import { numberTypeNode } from './NumberTypeNode';
 import { TypeNode, createTypeNodeFromIdl } from './TypeNode';
 
@@ -14,7 +14,7 @@ export type MapTypeNode = {
   // Children.
   readonly key: TypeNode;
   readonly value: TypeNode;
-  readonly size: SizeNode;
+  readonly count: CountNode;
 
   // Data.
   readonly idlMap: 'hashMap' | 'bTreeMap';
@@ -23,27 +23,27 @@ export type MapTypeNode = {
 export function mapTypeNode(
   key: TypeNode,
   value: TypeNode,
-  size?: SizeNode,
+  count?: CountNode,
   idlMap?: MapTypeNode['idlMap']
 ): MapTypeNode {
   return {
     kind: 'mapTypeNode',
     key,
     value,
-    size: size ?? prefixedSizeNode(numberTypeNode('u32')),
+    count: count ?? prefixedCountNode(numberTypeNode('u32')),
     idlMap: idlMap ?? 'hashMap',
   };
 }
 
 export function mapTypeNodeFromIdl(idl: IdlTypeMap): MapTypeNode {
   const [key, value] = 'hashMap' in idl ? idl.hashMap : idl.bTreeMap;
-  let size: SizeNode | undefined;
+  let size: CountNode | undefined;
   if (idl.size === 'remainder') {
-    size = remainderSizeNode();
+    size = remainderCountNode();
   } else if (typeof idl.size === 'number') {
-    size = fixedSizeNode(idl.size);
+    size = fixedCountNode(idl.size);
   } else if (idl.size) {
-    size = prefixedSizeNode(numberTypeNode(idl.size));
+    size = prefixedCountNode(numberTypeNode(idl.size));
   }
   return mapTypeNode(
     createTypeNodeFromIdl(key),

src/nodes/typeNodes/SetTypeNode.ts

@@ -1,10 +1,10 @@
 import type { IdlTypeSet } from '../../idl';
 import {
-  SizeNode,
-  fixedSizeNode,
-  prefixedSizeNode,
-  remainderSizeNode,
-} from '../sizeNodes';
+  CountNode,
+  fixedCountNode,
+  prefixedCountNode,
+  remainderCountNode,
+} from '../countNodes';
 import { numberTypeNode } from './NumberTypeNode';
 import { TypeNode, createTypeNodeFromIdl } from './TypeNode';
 
@@ -13,34 +13,34 @@ export type SetTypeNode = {
 
   // Children.
   readonly item: TypeNode;
-  readonly size: SizeNode;
+  readonly count: CountNode;
 
   // Data.
   readonly idlSet: 'hashSet' | 'bTreeSet';
 };
 
 export function setTypeNode(
   item: TypeNode,
-  size?: SizeNode,
+  count?: CountNode,
   idlSet?: SetTypeNode['idlSet']
 ): SetTypeNode {
   return {
     kind: 'setTypeNode',
     item,
-    size: size ?? prefixedSizeNode(numberTypeNode('u32')),
+    count: count ?? prefixedCountNode(numberTypeNode('u32')),
     idlSet: idlSet ?? 'hashSet',
   };
 }
 
 export function setTypeNodeFromIdl(idl: IdlTypeSet): SetTypeNode {
   const child = 'hashSet' in idl ? idl.hashSet : idl.bTreeSet;
-  let size: SetTypeNode['size'] | undefined;
+  let size: SetTypeNode['count'] | undefined;
   if (idl.size === 'remainder') {
-    size = remainderSizeNode();
+    size = remainderCountNode();
   } else if (typeof idl.size === 'number') {
-    size = fixedSizeNode(idl.size);
+    size = fixedCountNode(idl.size);
   } else if (idl.size) {
-    size = prefixedSizeNode(numberTypeNode(idl.size));
+    size = prefixedCountNode(numberTypeNode(idl.size));
   }
   return setTypeNode(
     createTypeNodeFromIdl(child),

src/renderers/js-experimental/fragments/discriminatorCondition.ts

@@ -95,7 +95,7 @@ function getFieldConditionFragment(
     isNode(field.type, 'arrayTypeNode') &&
     isNode(field.type.item, 'numberTypeNode') &&
     field.type.item.format === 'u8' &&
-    isNode(field.type.size, 'fixedSizeNode') &&
+    isNode(field.type.count, 'fixedCountNode') &&
     isNode(field.defaultValue, 'arrayValueNode') &&
     field.defaultValue.items.every(isNodeFilter('numberValueNode'))
   ) {