feat: 🎸 support inline Value in capacity estimator codegen

Author: streamich

src/codegen/capacity/CapacityEstimatorCodegen.ts

@@ -8,6 +8,7 @@ import {DiscriminatorCodegen} from '../discriminator';
 import {lazyKeyedFactory} from '../util';
 import {AbstractCodegen} from '../AbstractCodege';
 import type {SchemaPath} from '../types';
+import {Value} from '../../value';
 
 export type CompiledCapacityEstimator = (value: unknown) => number;
 
@@ -36,6 +37,10 @@ export class CapacityEstimatorCodegen extends AbstractCodegen<CompiledCapacityEs
       args: ['r0'],
       prologue: /* js */ `var size = 0;`,
       epilogue: /* js */ `return size;`,
+      linkable: {
+        Value,
+        get: CapacityEstimatorCodegen.get,
+      },
       processSteps: (steps) => {
         const stepsJoined: CodegenStepExecJs[] = [];
         for (let i = 0; i < steps.length; i++) {
@@ -58,7 +63,19 @@ export class CapacityEstimatorCodegen extends AbstractCodegen<CompiledCapacityEs
   protected onAny(path: SchemaPath, r: JsExpression, type: AnyType): void {
     const codegen = this.codegen;
     const rv = codegen.var(r.use());
-    codegen.js(/* js */ `size += maxEncodingCapacity(${rv});`);
+    codegen.link('Value');
+    codegen.link('get');
+    codegen.if(/* js */ `${rv} instanceof Value`, () => {
+      const rType = codegen.var(/* js */ `${rv}.type`);
+      const rData = codegen.var(/* js */ `${rv}.data`);
+      codegen.if(/* js */ `${rType}`, () => {
+        codegen.js(/* js */ `size += get(${rType})(${rData});`);
+      }, () => {
+        codegen.js(/* js */ `size += maxEncodingCapacity(${rData});`);
+      });
+    }, () => {
+      codegen.js(/* js */ `size += maxEncodingCapacity(${rv});`);
+    });
   }
 
   protected onCon(path: SchemaPath, r: JsExpression, type: ConType): void {

src/codegen/capacity/__tests__/CapacityEstimatorCodegenContext.spec.ts

@@ -3,6 +3,7 @@ import {t} from '../../../type';
 import {ModuleType} from '../../../type/classes/ModuleType';
 import {CapacityEstimatorCodegen} from '../CapacityEstimatorCodegen';
 import {Random} from '../../../random';
+import {unknown, Value} from '../../../value';
 
 describe('"any" type', () => {
   test('returns the same result as maxEncodingCapacity()', () => {
@@ -11,6 +12,26 @@ describe('"any" type', () => {
     const values = [null, true, false, 1, 123.123, '', 'adsf', [], {}, {foo: 'bar'}, [{a: [{b: null}]}]];
     for (const value of values) expect(estimator(value)).toBe(maxEncodingCapacity(value));
   });
+
+  test('can encode "any" field', () => {
+    const type = t.object({foo: t.any});
+    const estimator = CapacityEstimatorCodegen.get(type);
+    expect(estimator({foo: true})).toBe(maxEncodingCapacity({foo: true}));
+  });
+
+  test('can encode anon Value<unknown>', () => {
+    const type = t.object({foo: t.any});
+    const value = unknown('test');
+    const estimator = CapacityEstimatorCodegen.get(type);
+    expect(estimator({foo: value})).toBe(maxEncodingCapacity({foo: value.data}));
+  });
+
+  test('can encode typed Value<T>', () => {
+    const type = t.object({foo: t.any});
+    const value = new Value(123, t.con(123));
+    const estimator = CapacityEstimatorCodegen.get(type);
+    expect(estimator({foo: value})).toBe(maxEncodingCapacity({foo: value.data}));
+  });
 });
 
 describe('"con" type', () => {