feat: rename refactorings

Implement renaming refactoring: const→con, 3-letter Type classes, and schema field updates

Author: streamich

src/codegen/capacity/estimators.ts

@@ -6,6 +6,7 @@ import type {
   CompiledCapacityEstimator,
 } from './CapacityEstimatorCodegenContext';
 import type {Type} from '../../type';
+import type {ConType} from '../../type/classes/ConType';
 
 type EstimatorFunction = (ctx: CapacityEstimatorCodegenContext, value: JsExpression, type: Type) => void;
 
@@ -59,22 +60,22 @@ export const bin = (ctx: CapacityEstimatorCodegenContext, value: JsExpression):
 };
 
 export const const_ = (ctx: CapacityEstimatorCodegenContext, value: JsExpression, type: Type): void => {
-  const constType = type as any; // ConstType
+  const constType = type as ConType;
   ctx.inc(maxEncodingCapacity(constType.value()));
 };
 
 export const arr = (ctx: CapacityEstimatorCodegenContext, value: JsExpression, type: Type): void => {
   const codegen = ctx.codegen;
   ctx.inc(MaxEncodingOverhead.Array);
   const rLen = codegen.var(`${value.use()}.length`);
-  const arrayType = type as any; // ArrayType
+  const arrayType = type as any; // ArrType
   const elementType = arrayType.type;
   codegen.js(`size += ${MaxEncodingOverhead.ArrayElement} * ${rLen}`);
   const fn = elementType.compileCapacityEstimator({
     system: ctx.options.system,
     name: ctx.options.name,
   });
-  const isConstantSizeType = ['const', 'bool', 'num'].includes(elementType.getTypeName());
+  const isConstantSizeType = ['con', 'bool', 'num'].includes(elementType.getTypeName());
   if (isConstantSizeType) {
     const rFn = codegen.linkDependency(fn);
     codegen.js(`size += ${rLen} * ${rFn}(${elementType.random()});`);
@@ -90,7 +91,7 @@ export const arr = (ctx: CapacityEstimatorCodegenContext, value: JsExpression, t
 export const tup = (ctx: CapacityEstimatorCodegenContext, value: JsExpression, type: Type): void => {
   const codegen = ctx.codegen;
   const r = codegen.var(value.use());
-  const tupleType = type as any; // TupleType
+  const tupleType = type as any; // TupType
   const types = tupleType.types;
   const overhead = MaxEncodingOverhead.Array + MaxEncodingOverhead.ArrayElement * types.length;
   ctx.inc(overhead);
@@ -113,7 +114,7 @@ export const obj = (
 ): void => {
   const codegen = ctx.codegen;
   const r = codegen.var(value.use());
-  const objectType = type as any; // ObjectType
+  const objectType = type as any; // ObjType
   const encodeUnknownFields = !!objectType.schema.encodeUnknownFields;
   if (encodeUnknownFields) {
     codegen.js(`size += maxEncodingCapacity(${r});`);
@@ -142,7 +143,7 @@ export const map = (ctx: CapacityEstimatorCodegenContext, value: JsExpression, t
   const rLen = codegen.var(`${rKeys}.length`);
   codegen.js(`size += ${MaxEncodingOverhead.ObjectElement} * ${rLen}`);
   const mapType = type as any; // MapType
-  const valueType = mapType.type;
+  const valueType = mapType.valueType;
   const fn = valueType.compileCapacityEstimator({
     system: ctx.options.system,
     name: ctx.options.name,
@@ -209,7 +210,7 @@ export const generate = (ctx: CapacityEstimatorCodegenContext, value: JsExpressi
     case 'bin':
       bin(ctx, value);
       break;
-    case 'const':
+    case 'con':
       const_(ctx, value, type);
       break;
     case 'arr':

src/codegen/validator/util.ts

@@ -1,6 +1,6 @@
 export const canSkipObjectKeyUndefinedCheck = (type: string): boolean => {
   switch (type) {
-    case 'const':
+    case 'con':
     case 'bool':
     case 'num':
     case 'str':

src/json-schema/converter.ts

@@ -1,16 +1,16 @@
-import type {AbstractType} from '../type/classes/AbstractType';
+import type {AbsType} from '../type/classes/AbsType';
 import type {AnyType} from '../type/classes/AnyType';
-import type {ArrayType} from '../type/classes/ArrayType';
-import type {BinaryType} from '../type/classes/BinaryType';
-import type {BooleanType} from '../type/classes/BooleanType';
-import type {ConstType} from '../type/classes/ConstType';
+import type {ArrType} from '../type/classes/ArrType';
+import type {BinType} from '../type/classes/BinType';
+import type {BoolType} from '../type/classes/BoolType';
+import type {ConType} from '../type/classes/ConType';
 import type {MapType} from '../type/classes/MapType';
-import type {NumberType} from '../type/classes/NumberType';
-import type {ObjectType} from '../type/classes/ObjectType';
+import type {NumType} from '../type/classes/NumType';
+import type {ObjType} from '../type/classes/ObjType';
 import type {OrType} from '../type/classes/OrType';
 import type {RefType} from '../type/classes/RefType';
-import type {StringType} from '../type/classes/StringType';
-import type {TupleType} from '../type/classes/TupleType';
+import type {StrType} from '../type/classes/StrType';
+import type {TupType} from '../type/classes/TupType';
 import type {TypeExportContext} from '../system/TypeExportContext';
 import type * as schema from '../schema';
 import type {
@@ -30,9 +30,9 @@ import type {
 
 /**
  * Extracts the base JSON Schema properties that are common to all types.
- * This replaces the logic from AbstractType.toJsonSchema().
+ * This replaces the logic from AbsType.toJsonSchema().
  */
-function getBaseJsonSchema(type: AbstractType<any>, ctx?: TypeExportContext): JsonSchemaGenericKeywords {
+function getBaseJsonSchema(type: AbsType<any>, ctx?: TypeExportContext): JsonSchemaGenericKeywords {
   const typeSchema = type.getSchema();
   const jsonSchema: JsonSchemaGenericKeywords = {};
 
@@ -49,34 +49,34 @@ function getBaseJsonSchema(type: AbstractType<any>, ctx?: TypeExportContext): Js
  * Main router function that converts a type to JSON Schema using a switch statement.
  * This replaces the individual toJsonSchema() methods on each type class.
  */
-export function typeToJsonSchema(type: AbstractType<any>, ctx?: TypeExportContext): JsonSchemaNode {
+export function typeToJsonSchema(type: AbsType<any>, ctx?: TypeExportContext): JsonSchemaNode {
   const typeName = type.getTypeName();
 
   switch (typeName) {
     case 'any':
       return anyToJsonSchema(type as AnyType, ctx);
     case 'arr':
-      return arrayToJsonSchema(type as ArrayType<any>, ctx);
+      return arrayToJsonSchema(type as ArrType<any>, ctx);
     case 'bin':
-      return binaryToJsonSchema(type as BinaryType<any>, ctx);
+      return binaryToJsonSchema(type as BinType<any>, ctx);
     case 'bool':
-      return booleanToJsonSchema(type as BooleanType, ctx);
-    case 'const':
-      return constToJsonSchema(type as ConstType<any>, ctx);
+      return booleanToJsonSchema(type as BoolType, ctx);
+    case 'con':
+      return constToJsonSchema(type as ConType<any>, ctx);
     case 'map':
       return mapToJsonSchema(type as MapType<any>, ctx);
     case 'num':
-      return numberToJsonSchema(type as NumberType, ctx);
+      return numberToJsonSchema(type as NumType, ctx);
     case 'obj':
-      return objectToJsonSchema(type as ObjectType<any>, ctx);
+      return objectToJsonSchema(type as ObjType<any>, ctx);
     case 'or':
       return orToJsonSchema(type as OrType<any>, ctx);
     case 'ref':
       return refToJsonSchema(type as RefType<any>, ctx);
     case 'str':
-      return stringToJsonSchema(type as StringType, ctx);
+      return stringToJsonSchema(type as StrType, ctx);
     case 'tup':
-      return tupleToJsonSchema(type as TupleType<any>, ctx);
+      return tupleToJsonSchema(type as TupType<any>, ctx);
     default:
       // Fallback to base implementation for unknown types
       return getBaseJsonSchema(type, ctx);
@@ -97,7 +97,7 @@ function anyToJsonSchema(type: AnyType, ctx?: TypeExportContext): JsonSchemaAny
   return result;
 }
 
-function arrayToJsonSchema(type: ArrayType<any>, ctx?: TypeExportContext): JsonSchemaArray {
+function arrayToJsonSchema(type: ArrType<any>, ctx?: TypeExportContext): JsonSchemaArray {
   const schema = type.getSchema();
   const baseSchema = getBaseJsonSchema(type, ctx);
   const result: JsonSchemaArray = {
@@ -114,7 +114,7 @@ function arrayToJsonSchema(type: ArrayType<any>, ctx?: TypeExportContext): JsonS
   return result;
 }
 
-function binaryToJsonSchema(type: BinaryType<any>, ctx?: TypeExportContext): JsonSchemaBinary {
+function binaryToJsonSchema(type: BinType<any>, ctx?: TypeExportContext): JsonSchemaBinary {
   const baseSchema = getBaseJsonSchema(type, ctx);
   const result: JsonSchemaBinary = {
     type: 'binary' as any,
@@ -126,7 +126,7 @@ function binaryToJsonSchema(type: BinaryType<any>, ctx?: TypeExportContext): Jso
   return result;
 }
 
-function booleanToJsonSchema(type: BooleanType, ctx?: TypeExportContext): JsonSchemaBoolean {
+function booleanToJsonSchema(type: BoolType, ctx?: TypeExportContext): JsonSchemaBoolean {
   const baseSchema = getBaseJsonSchema(type, ctx);
   const result: JsonSchemaBoolean = {
     type: 'boolean',
@@ -138,7 +138,7 @@ function booleanToJsonSchema(type: BooleanType, ctx?: TypeExportContext): JsonSc
   return result;
 }
 
-function constToJsonSchema(type: ConstType<any>, ctx?: TypeExportContext): JsonSchemaNode {
+function constToJsonSchema(type: ConType<any>, ctx?: TypeExportContext): JsonSchemaNode {
   const schema = type.getSchema();
   const baseSchema = getBaseJsonSchema(type, ctx);
   const value = schema.value;
@@ -204,7 +204,7 @@ function mapToJsonSchema(type: MapType<any>, ctx?: TypeExportContext): JsonSchem
   const result: JsonSchemaObject = {
     type: 'object',
     patternProperties: {
-      '.*': typeToJsonSchema((type as any).type, ctx),
+      '.*': typeToJsonSchema((type as any).valueType, ctx),
     },
   };
 
@@ -214,7 +214,7 @@ function mapToJsonSchema(type: MapType<any>, ctx?: TypeExportContext): JsonSchem
   return result;
 }
 
-function numberToJsonSchema(type: NumberType, ctx?: TypeExportContext): JsonSchemaNumber {
+function numberToJsonSchema(type: NumType, ctx?: TypeExportContext): JsonSchemaNumber {
   const schema = type.getSchema();
   const baseSchema = getBaseJsonSchema(type, ctx);
   const result: JsonSchemaNumber = {
@@ -238,7 +238,7 @@ function numberToJsonSchema(type: NumberType, ctx?: TypeExportContext): JsonSche
   return result;
 }
 
-function objectToJsonSchema(type: ObjectType<any>, ctx?: TypeExportContext): JsonSchemaObject {
+function objectToJsonSchema(type: ObjType<any>, ctx?: TypeExportContext): JsonSchemaObject {
   const schema = type.getSchema();
   const baseSchema = getBaseJsonSchema(type, ctx);
   const result: JsonSchemaObject = {
@@ -294,7 +294,7 @@ function refToJsonSchema(type: RefType<any>, ctx?: TypeExportContext): JsonSchem
   return result;
 }
 
-function stringToJsonSchema(type: StringType, ctx?: TypeExportContext): JsonSchemaString {
+function stringToJsonSchema(type: StrType, ctx?: TypeExportContext): JsonSchemaString {
   const schema = type.getSchema();
   const baseSchema = getBaseJsonSchema(type, ctx);
   const result: JsonSchemaString = {
@@ -323,7 +323,7 @@ function stringToJsonSchema(type: StringType, ctx?: TypeExportContext): JsonSche
   return result;
 }
 
-function tupleToJsonSchema(type: TupleType<any>, ctx?: TypeExportContext): JsonSchemaArray {
+function tupleToJsonSchema(type: TupType<any>, ctx?: TypeExportContext): JsonSchemaArray {
   const baseSchema = getBaseJsonSchema(type, ctx);
   const types = (type as any).types;
   const result: JsonSchemaArray = {

src/jtd/converter.ts

@@ -27,7 +27,7 @@ export function toJtdForm(schema: schema.Schema): jtd.JtdForm {
       const form: jtd.JtdTypeForm = {type: 'boolean'};
       return form;
     }
-    case 'const': {
+    case 'con': {
       const constSchema = schema as schema.ConstSchema;
       const value = constSchema.value;
       const valueType = typeof value;
@@ -77,7 +77,7 @@ export function toJtdForm(schema: schema.Schema): jtd.JtdForm {
 
         for (const field of objSchema.fields) {
           const fieldName = field.key;
-          const fieldType = field.type;
+          const fieldType = field.value;
 
           if (fieldType) {
             const fieldJtd = toJtdForm(fieldType);
@@ -107,7 +107,7 @@ export function toJtdForm(schema: schema.Schema): jtd.JtdForm {
     case 'map': {
       const mapSchema = schema as schema.MapSchema;
       return {
-        values: toJtdForm(mapSchema.type),
+        values: toJtdForm(mapSchema.value),
       };
     }
     case 'ref': {

src/random/__tests__/random.spec.ts

@@ -240,10 +240,10 @@ describe('random generators', () => {
 
     test('handles edge cases and constraints', () => {
       // Empty array constraint
-      const emptyArrayType = t.Array(t.String(), {max: 0});
-      const emptyArray = emptyArrayType.random();
+      const emptyArrType = t.Array(t.String(), {max: 0});
+      const emptyArray = emptyArrType.random();
       expect(emptyArray).toEqual([]);
-      emptyArrayType.validate(emptyArray);
+      emptyArrType.validate(emptyArray);
 
       // Single item array constraint
       const singleItemType = t.Array(t.Number(), {min: 1, max: 1});

src/random/generator.ts

@@ -1,55 +1,55 @@
-import type {AbstractType} from '../type/classes/AbstractType';
+import type {AbsType} from '../type/classes/AbsType';
 import type {AnyType} from '../type/classes/AnyType';
-import type {ArrayType} from '../type/classes/ArrayType';
-import type {BinaryType} from '../type/classes/BinaryType';
-import type {BooleanType} from '../type/classes/BooleanType';
-import type {ConstType} from '../type/classes/ConstType';
-import type {FunctionType} from '../type/classes/FunctionType';
+import type {ArrType} from '../type/classes/ArrType';
+import type {BinType} from '../type/classes/BinType';
+import type {BoolType} from '../type/classes/BoolType';
+import type {ConType} from '../type/classes/ConType';
+import type {FnType} from '../type/classes/FnType';
 import type {MapType} from '../type/classes/MapType';
-import type {NumberType} from '../type/classes/NumberType';
-import type {ObjectType} from '../type/classes/ObjectType';
+import type {NumType} from '../type/classes/NumType';
+import type {ObjType} from '../type/classes/ObjType';
 import type {OrType} from '../type/classes/OrType';
 import type {RefType} from '../type/classes/RefType';
-import type {StringType} from '../type/classes/StringType';
-import type {TupleType} from '../type/classes/TupleType';
+import type {StrType} from '../type/classes/StrType';
+import type {TupType} from '../type/classes/TupType';
 
 import * as gen from './generators';
 
 /**
  * Main router function that dispatches to the correct random generator based on the type's kind.
  * This replaces the individual random() methods in each type class.
  */
-export function random(type: AbstractType<any>): unknown {
+export function random(type: AbsType<any>): unknown {
   const kind = type.getTypeName();
 
   switch (kind) {
     case 'any':
       return gen.any(type as AnyType);
     case 'arr':
-      return gen.arr(type as ArrayType<any>);
+      return gen.arr(type as ArrType<any>);
     case 'bin':
-      return gen.bin(type as BinaryType<any>);
+      return gen.bin(type as BinType<any>);
     case 'bool':
-      return gen.bool(type as BooleanType);
-    case 'const':
-      return gen.const_(type as ConstType);
+      return gen.bool(type as BoolType);
+    case 'con':
+      return gen.const_(type as ConType);
     case 'fn':
     case 'fn$':
-      return gen.fn(type as FunctionType<any, any>);
+      return gen.fn(type as FnType<any, any>);
     case 'map':
       return gen.map(type as MapType<any>);
     case 'num':
-      return gen.num(type as NumberType);
+      return gen.num(type as NumType);
     case 'obj':
-      return gen.obj(type as ObjectType<any>);
+      return gen.obj(type as ObjType<any>);
     case 'or':
       return gen.or(type as OrType<any>);
     case 'ref':
       return gen.ref(type as RefType<any>);
     case 'str':
-      return gen.str(type as StringType);
+      return gen.str(type as StrType);
     case 'tup':
-      return gen.tup(type as TupleType<any>);
+      return gen.tup(type as TupType<any>);
     default:
       // Fallback to generic random JSON for unknown types
       return gen.any(type as AnyType);