feat(generator): add support for arrays

[Wykerd]

Adds better inference support for arrays to the YTNode generator.

Before:

class Test extends YTNode {
  static type = 'Test';

  array: {
    0: {
      key1: string
    },
    1: {
      key1: string,
      key2: boolean
    }
  };

  constructor(data: RawNode) {
    super();
    this.array = {
      0: {
        key1: data.array.0.key1
      },
      1: {
        key1: data.array.1.key1,
        key2: data.array.1.key2
      }
    };
  }
}

After:

class Test extends YTNode {
  static type = 'Test';

  array: {
    key1: string,
    key2?: boolean
  }[];

  constructor(data: RawNode) {
    super();
    this.array = data.array.map((item: any) => ({
      key1: item.key1,
      key2: Reflect.has(item, 'key2') ? item.key2 : undefined
    }));
  }
}

[Wykerd]

Initial tests with this script seem to be working (see below). Just need to test that render lists still work as expected.

import { camelToSnake, generateRuntimeClass, generateTypescriptClass } from './parser/generator.js';

const TestItem = generateRuntimeClass('TestItem', {
    contents: []
}, (err) => {
    if (err.error_type === 'class_not_found') {
        console.warn(
            `Introspected and JIT generated this class in the meantime:\n${generateTypescriptClass(err.classname, err.key_info)}`
        );
    }
    if (err.error_type === 'class_changed') {
        console.warn(
            `The following keys where altered: ${err.changed_keys.map(([ key ]) => camelToSnake(key)).join(', ')}\n` +
            `The class has changed to:\n${generateTypescriptClass(err.classname, err.key_info)}`
        )
    }
});

console.log(new TestItem({
    contents: [
        {
            test: 'test1',
            item: 1
        },
        {
            test: 'test2',
            item: 2,
            error_reasons: [
                {
                    code: 123,
                    message: 'test'
                }
            ]
        }
    ]
}));

console.log(new TestItem({
    contents: [
        {
            test: 'test3',
            item: 3,
            error_reasons: [
                {
                    code: 500,
                    message: 'fatal',
                    fatal: true
                }
            ]
        }
    ]
}));

Producing the following TypeScript classes:

Introspected and JIT generated this class in the meantime:
class TestItem extends YTNode {
  static type = 'TestItem';

  contents: never[];

  constructor(data: RawNode) {
    super();
    this.contents = data.contents;
  }
}

The following keys where altered: contents
The class has changed to:
class TestItem extends YTNode {
  static type = 'TestItem';

  contents: {
    test: string,
    item: number,
    error_reasons?: {
      code: number,
      message: string
    }[]
  }[];

  constructor(data: RawNode) {
    super();
    this.contents = data.contents.map((item: any) => ({
      test: item.test,
      item: item.item,
      error_reasons: Reflect.has(item, 'error_reasons') ? item.error_reasons.map((item: any) => ({
        code: item.code,
        message: item.message
      })) : undefined
    }));
  }
}

TestItem {
  type: 'TestItem',
  contents: [
    { test: 'test1', item: 1, error_reasons: undefined },
    { test: 'test2', item: 2, error_reasons: [Array] }
  ]
}
The following keys where altered: contents
The class has changed to:
class TestItem extends YTNode {
  static type = 'TestItem';

  contents: {
    test: string,
    item: number,
    error_reasons?: {
      code: number,
      message: string,
      fatal?: boolean
    }[]
  }[];

  constructor(data: RawNode) {
    super();
    this.contents = data.contents.map((item: any) => ({
      test: item.test,
      item: item.item,
      error_reasons: Reflect.has(item, 'error_reasons') ? item.error_reasons.map((item: any) => ({
        code: item.code,
        message: item.message,
        fatal: Reflect.has(item, 'fatal') ? item.fatal : undefined
      })) : undefined
    }));
  }
}

TestItem {
  type: 'TestItem',
  contents: [ { test: 'test3', item: 3, error_reasons: [Array] } ]
}

[Wykerd]

Tested with ClipCloud. Seems to still generate valid runtime and TS classes for renderer lists.

class ChipCloud extends YTNode {
  static type = 'ChipCloud';

  chips: ObservedArray<YTNodes.ChipCloudChip> | null;
  horizontal_scrollable: boolean;

  constructor(data: RawNode) {
    super();
    this.chips = Parser.parse(data.chips, true, YTNodes.ChipCloudChip);
    this.horizontal_scrollable = data.horizontalScrollable;
  }
}