@loro-extended/change 0.6.0 → 0.8.0

package/src/types.ts

@@ -5,21 +5,53 @@
 
 import type { ContainerShape, DocShape, Shape } from "./shape.js"
 
-// Input type inference - what developers can pass to push/insert methods
-export type InferPlainType<T> = T extends Shape<infer P, any, any> ? P : never
+/**
+ * Infers the plain (JSON-serializable) type from any Shape.
+ *
+ * This is the recommended way to extract types from shapes.
+ * Works with DocShape, ContainerShape, and ValueShape.
+ *
+ * @example
+ * ```typescript
+ * const ChatSchema = Shape.doc({
+ *   messages: Shape.list(Shape.map({
+ *     id: Shape.plain.string(),
+ *     content: Shape.text(),
+ *   })),
+ * })
+ *
+ * // Extract the document type
+ * type ChatDoc = Infer<typeof ChatSchema>
+ * // Result: { messages: { id: string; content: string }[] }
+ *
+ * const PresenceSchema = Shape.plain.object({
+ *   name: Shape.plain.string(),
+ *   cursor: Shape.plain.object({ x: Shape.plain.number(), y: Shape.plain.number() }),
+ * })
+ *
+ * // Extract the presence type
+ * type Presence = Infer<typeof PresenceSchema>
+ * // Result: { name: string; cursor: { x: number; y: number } }
+ * ```
+ */
+export type Infer<T> = T extends Shape<infer P, any, any> ? P : never
 
 export type InferDraftType<T> = T extends Shape<any, infer D, any> ? D : never
 
 /**
- * Extracts the valid empty state type from a shape.
+ * Extracts the valid placeholder type from a shape.
  *
  * For dynamic containers (list, record, etc.), this will be constrained to
  * empty values ([] or {}) to prevent users from expecting per-entry merging.
  */
-export type InferEmptyStateType<T> = T extends Shape<any, any, infer E>
-  ? E
+export type InferPlaceholderType<T> = T extends Shape<any, any, infer P>
+  ? P
   : never
 
 // Draft-specific type inference that properly handles the draft context
 export type Draft<T extends DocShape<Record<string, ContainerShape>>> =
   InferDraftType<T>
+
+export type DeepReadonly<T> = {
+  readonly [P in keyof T]: DeepReadonly<T[P]>
+}

package/src/utils/type-guards.ts

@@ -197,6 +197,7 @@ export function isValueShape(
       "record",
       "array",
       "union",
+      "discriminatedUnion",
     ].includes(schema.valueType)
   )
 }

package/src/validation.ts

@@ -1,6 +1,7 @@
 import type {
   ArrayValueShape,
   ContainerOrValueShape,
+  DiscriminatedUnionValueShape,
   DocShape,
   ListContainerShape,
   MapContainerShape,
@@ -12,7 +13,7 @@ import type {
   UnionValueShape,
   ValueShape,
 } from "./shape.js"
-import type { InferPlainType } from "./types.js"
+import type { Infer } from "./types.js"
 
 /**
  * Validates a value against a ContainerShape or ValueShape schema
@@ -233,6 +234,38 @@ export function validateValue(
         )
       }
 
+      case "discriminatedUnion": {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+          throw new Error(
+            `Expected object at path ${currentPath}, got ${typeof value}`,
+          )
+        }
+
+        const unionSchema = valueSchema as DiscriminatedUnionValueShape
+        const discriminantKey = unionSchema.discriminantKey
+        const discriminantValue = (value as Record<string, unknown>)[
+          discriminantKey
+        ]
+
+        if (typeof discriminantValue !== "string") {
+          throw new Error(
+            `Expected string for discriminant key "${discriminantKey}" at path ${currentPath}, got ${typeof discriminantValue}`,
+          )
+        }
+
+        const variantSchema = unionSchema.variants[discriminantValue]
+
+        if (!variantSchema) {
+          throw new Error(
+            `Invalid discriminant value "${discriminantValue}" at path ${currentPath}. Expected one of: ${Object.keys(
+              unionSchema.variants,
+            ).join(", ")}`,
+          )
+        }
+
+        return validateValue(value, variantSchema, currentPath)
+      }
+
       default:
         throw new Error(`Unknown value type: ${(valueSchema as any).valueType}`)
     }
@@ -242,28 +275,28 @@ export function validateValue(
 }
 
 /**
- * Validates empty state against schema structure without using Zod
- * Combines the functionality of createEmptyStateValidator and createValueValidator
+ * Validates placeholder against schema structure without using Zod
+ * Combines the functionality of createPlaceholderValidator and createValueValidator
  */
-export function validateEmptyState<T extends DocShape>(
-  emptyState: unknown,
+export function validatePlaceholder<T extends DocShape>(
+  placeholder: unknown,
   schema: T,
-): InferPlainType<T> {
+): Infer<T> {
   if (
-    !emptyState ||
-    typeof emptyState !== "object" ||
-    Array.isArray(emptyState)
+    !placeholder ||
+    typeof placeholder !== "object" ||
+    Array.isArray(placeholder)
   ) {
-    throw new Error("Empty state must be an object")
+    throw new Error("Placeholder must be an object")
   }
 
   const result: Record<string, unknown> = {}
 
   // Validate each property in the document schema
   for (const [key, schemaValue] of Object.entries(schema.shapes)) {
-    const value = (emptyState as Record<string, unknown>)[key]
+    const value = (placeholder as Record<string, unknown>)[key]
     result[key] = validateValue(value, schemaValue, key)
   }
 
-  return result as InferPlainType<T>
+  return result as Infer<T>
 }