Data model

src/data/data.ts

@@ -9,16 +9,28 @@ export interface File {
     readonly blocks: ReadonlyArray<Block>
 }
 
+export function File(blocks: ArrayLike<Block>, name?: string): File {
+    return { name, blocks: blocks as any };
+}
+
 export interface Block {
     readonly header?: string,
     readonly categories: { readonly [name: string]: Category }
 }
 
+export function Block(categories: { readonly [name: string]: Category }, header?: string): Block {
+    return { header, categories };
+}
+
 export interface Category {
     readonly rowCount: number,
     getField(name: string): Field | undefined
 }
 
+export function Category(rowCount: number, fields: { [name: string]: Field }): Category {
+    return { rowCount, getField(name) { return fields[name]; } };
+}
+
 export namespace Category {
     export const Empty: Category = { rowCount: 0, getField(name: string) { return void 0; } };
 }
@@ -29,7 +41,7 @@ export const enum ValuePresence {
     Unknown = 2
 }
 
-export type FieldArray = number[] | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array
+export type FieldArray = string[] | number[] | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array
 
 /**
  * Implementation note:

src/data/schema.ts

@@ -23,10 +23,11 @@ import * as Data from './data'
 export type BlockDefinition = { [category: string]: CategoryDefinition }
 export type CategoryDefinition = { '@alias'?: string } & { [field: string]: Field.Schema<any> }
 
-export type Schema<Definition extends BlockDefinition> = Block<{ [C in keyof Definition]: Category<{ [F in keyof Definition[C]]: Field<Definition[C][F]['type']> }> }>
+export type BlockInstance<Definition extends BlockDefinition> = Block<{ [C in keyof Definition]: CategoryInstance<Definition[C]> }>
+export type CategoryInstance<Definition extends CategoryDefinition> = Category<{ [F in keyof Definition]: Field<Definition[F]['type']> }>
 
-export function apply<T extends BlockDefinition>(schema: T, block: Data.Block): Schema<T> {
-    return createBlock(schema, block) as Schema<T>;
+export function apply<Definition extends BlockDefinition>(schema: Definition, block: Data.Block): BlockInstance<Definition> {
+    return createBlock(schema, block) as BlockInstance<Definition>;
 }
 
 export type Block<Categories> = Categories & {

src/data/spec/schema.spec.ts

@@ -34,17 +34,8 @@ function Field(values: any[]): Data.Field {
     }
 }
 
-class Category implements Data.Category {
-    getField(name: string) { return this.fields[name]; }
-    constructor(public rowCount: number, private fields: any) { }
-}
-
-class Block implements Data.Block {
-    constructor(public categories: { readonly [name: string]: Data.Category }, public header?: string) { }
-}
-
-const testBlock = new Block({
-    'atoms': new Category(2, {
+const testBlock = Data.Block({
+    'atoms': Data.Category(2, {
         x: Field([1, 2]),
         name: Field(['C', 'O'])
     })