@lagless/codegen 0.0.33

package/dist/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/generator.ts"],"sourcesContent":["import { ECSSchema, FieldDefinition } from '@lagless/core';\nimport { generateFromTemplate as processTemplate, FileOperations } from './template-engine.js';\nimport { FieldTypeReverse, getTypeSizeBytes, typedArrayConstructors, typeToArrayConstructor } from '@lagless/binary';\n\nexport interface GenerateCodeOptions {\n  schema: ECSSchema;\n  projectName: string;\n  outputDir: string;\n  templateDir: string;\n  fileOperations: FileOperations;\n}\n\nexport function generateBarrelFileContent(schema: ECSSchema, projectName: string): string {\n  let content = '// Generated by @lagless/codegen. Do not edit manually.\\n\\n';\n\n  // Export components\n  schema.components.forEach((component) => {\n    content += `export * from './${component.name}.js';\\n`;\n  });\n\n  // Export singletons\n  schema.singletons.forEach((singleton) => {\n    content += `export * from './${singleton.name}.js';\\n`;\n  });\n\n  // Export player resources\n  schema.playerResources.forEach((playerResource) => {\n    content += `export * from './${playerResource.name}.js';\\n`;\n  });\n\n  // Export filters\n  schema.filters.forEach((filter) => {\n    content += `export * from './${filter.name}.js';\\n`;\n  });\n\n  // Export inputs\n  schema.inputs.forEach((input) => {\n    content += `export * from './${input.name}.js';\\n`;\n  });\n\n  // Export input registry\n  content += `export * from './${projectName}InputRegistry.js';\\n`;\n\n  // Export core\n  content += `export * from './${projectName}.core.js';\\n`;\n\n  // Export runner\n  content += `export * from './${projectName}.runner.js';\\n`;\n\n  return content;\n}\n\nexport async function generateCode(options: GenerateCodeOptions): Promise<void> {\n  const { schema, projectName, outputDir, templateDir, fileOperations } = options;\n  const { writeFile, joinPath, exists } = fileOperations;\n\n  // Ensure output directory exists\n  if (!exists(outputDir)) {\n    writeFile(joinPath(outputDir, '.gitkeep'), '');\n  }\n\n  // Generate component classes\n  for (const component of schema.components) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'component'),\n      outputDir,\n      data: {\n        ...component,\n        component,\n        projectName,\n        typeToArrayConstructor,\n        getFieldByteSize: (field: FieldDefinition) => {\n          const baseSize = getTypeSizeBytes(field.type);\n          return field.isArray ? baseSize * field.arrayLength! : baseSize;\n        },\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate singleton classes\n  for (const singleton of schema.singletons) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'singleton'),\n      outputDir,\n      data: {\n        ...singleton,\n        singleton,\n        projectName,\n        typeToArrayConstructor,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate playerResource classes\n  for (const playerResource of schema.playerResources) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'playerResource'),\n      outputDir,\n      data: {\n        ...playerResource,\n        playerResource,\n        projectName,\n        typeToArrayConstructor,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate Filter classes\n  for (const filter of schema.filters) {\n    const componentsImports = [...filter.include, ...filter.exclude].map((c) => c.name);\n    const includeMask = filter.include.reduce((acc, component) => acc | component.id, 0);\n    const excludeMask = filter.exclude.reduce((acc, component) => acc | component.id, 0);\n\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'filter'),\n      outputDir,\n      data: {\n        filter,\n        includeMask,\n        excludeMask,\n        componentsImports,\n        name: filter.name,\n        projectName,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate Input classes\n  for (const input of schema.inputs) {\n    await processTemplate({\n      templateDir: joinPath(templateDir, 'input'),\n      outputDir,\n      data: {\n        ...input,\n        input,\n        projectName,\n        FieldTypeReverse,\n        typedArrayConstructors,\n      },\n      fileOperations,\n    });\n  }\n\n  // Generate input registry\n  await processTemplate({\n    templateDir: joinPath(templateDir, 'input-registry'),\n    outputDir,\n    data: {\n      projectName,\n      inputs: schema.inputs,\n      schema,\n    },\n    fileOperations,\n  });\n\n  // Generate ECSCore class\n  await processTemplate({\n    templateDir: joinPath(templateDir, 'core'),\n    outputDir,\n    data: {\n      projectName,\n      schema,\n    },\n    fileOperations,\n  });\n\n  // Generate Runner class\n  await processTemplate({\n    templateDir: joinPath(templateDir, 'runner'),\n    outputDir,\n    data: {\n      projectName,\n      schema,\n    },\n    fileOperations,\n  });\n\n  // Generate barrel file\n  const barrelContent = generateBarrelFileContent(schema, projectName);\n  writeFile(joinPath(outputDir, 'index.ts'), barrelContent);\n}\n"],"names":["generateFromTemplate","processTemplate","FieldTypeReverse","getTypeSizeBytes","typedArrayConstructors","typeToArrayConstructor","generateBarrelFileContent","schema","projectName","content","components","forEach","component","name","singletons","singleton","playerResources","playerResource","filters","filter","inputs","input","generateCode","options","outputDir","templateDir","fileOperations","writeFile","joinPath","exists","data","getFieldByteSize","field","baseSize","type","isArray","arrayLength","componentsImports","include","exclude","map","c","includeMask","reduce","acc","id","excludeMask","barrelContent"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './parser.js';
+export * from './generator.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './parser.js';\nexport * from './generator.js';\n"],"names":[],"rangeMappings":";","mappings":"AAAA,cAAc,cAAc;AAC5B,cAAc,iBAAiB"}

package/dist/nx-generator.js

@@ -0,0 +1,66 @@
+import { formatFiles, joinPathFragments } from '@nx/devkit';
+import { parseYamlConfig } from './parser.js';
+import { generateCode } from './generator.js';
+import * as fs from 'fs';
+import { DIRNAME } from './dirname.js';
+export default async function(tree, options) {
+    // Read and parse YAML config
+    const configPath = options.configPath;
+    if (!tree.exists(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    const configContent = tree.read(configPath, 'utf-8');
+    if (!configContent) throw new Error(`Config file is empty: ${configPath}`);
+    const { schema, projectName } = parseYamlConfig(configContent, configPath);
+    // Generate output directory from config path (../code-gen)
+    const outputDir = joinPathFragments(configPath, '../code-gen');
+    const templateDir = joinPathFragments(DIRNAME, '..', 'files');
+    // Create file operations adapter for NX Tree
+    const fileOperations = {
+        writeFile: (path, content)=>tree.write(path, content),
+        // Only writeFile uses tree, other methods use fs
+        readFile: (path)=>fs.readFileSync(path, 'utf-8'),
+        joinPath: (...segments)=>joinPathFragments(...segments),
+        exists: (path)=>{
+            try {
+                fs.accessSync(path, fs.constants.F_OK);
+                return true;
+            } catch (e) {
+                return false;
+            }
+        },
+        readDir: (path)=>{
+            try {
+                return fs.readdirSync(path);
+            } catch (e) {
+                return [];
+            }
+        },
+        isDirectory: (path)=>{
+            try {
+                return fs.statSync(path).isDirectory();
+            } catch (e) {
+                return false;
+            }
+        }
+    };
+    if (!tree.exists(outputDir)) {
+        tree.write(joinPathFragments(outputDir, '.gitkeep'), '');
+    }
+    // Generate code using the unified template engine
+    await generateCode({
+        schema,
+        projectName,
+        outputDir,
+        templateDir,
+        fileOperations
+    });
+    await formatFiles(tree);
+    return ()=>{
+        console.log('ECS code generation complete!');
+        console.log(`Generated ${schema.components.length} components and ${schema.singletons.length} singletons.`);
+        console.log(`Project name: ${projectName}`);
+    };
+}
+
+//# sourceMappingURL=nx-generator.js.map

package/dist/nx-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/nx-generator.ts"],"sourcesContent":["import { Tree, formatFiles, joinPathFragments } from '@nx/devkit';\nimport { parseYamlConfig } from './parser.js';\nimport { generateCode } from './generator.js';\nimport { FileOperations } from './template-engine.js';\nimport * as fs from 'fs';\nimport { DIRNAME } from './dirname.js';\n\ninterface GeneratorOptions {\n  configPath: string;\n}\n\nexport default async function (tree: Tree, options: GeneratorOptions) {\n  // Read and parse YAML config\n  const configPath = options.configPath;\n  if (!tree.exists(configPath)) {\n    throw new Error(`Config file not found: ${configPath}`);\n  }\n\n  const configContent = tree.read(configPath, 'utf-8');\n  if (!configContent) throw new Error(`Config file is empty: ${configPath}`);\n\n  const { schema, projectName } = parseYamlConfig(configContent, configPath);\n\n  // Generate output directory from config path (../code-gen)\n  const outputDir = joinPathFragments(configPath, '../code-gen');\n  const templateDir = joinPathFragments(DIRNAME, '..', 'files');\n\n  // Create file operations adapter for NX Tree\n  const fileOperations: FileOperations = {\n    writeFile: (path: string, content: string) => tree.write(path, content),\n    // Only writeFile uses tree, other methods use fs\n    readFile: (path: string) => fs.readFileSync(path, 'utf-8'),\n    joinPath: (...segments: string[]) => joinPathFragments(...segments),\n    exists: (path: string) => {\n      try {\n        fs.accessSync(path, fs.constants.F_OK);\n        return true;\n      } catch {\n        return false;\n      }\n    },\n    readDir: (path: string) => {\n      try {\n        return fs.readdirSync(path);\n      } catch {\n        return [];\n      }\n    },\n    isDirectory: (path: string) => {\n      try {\n        return fs.statSync(path).isDirectory();\n      } catch {\n        return false;\n      }\n    },\n  };\n\n  if (!tree.exists(outputDir)) {\n    tree.write(joinPathFragments(outputDir, '.gitkeep'), '');\n  }\n\n  // Generate code using the unified template engine\n  await generateCode({\n    schema,\n    projectName,\n    outputDir,\n    templateDir,\n    fileOperations,\n  });\n\n  await formatFiles(tree);\n\n  return () => {\n    console.log('ECS code generation complete!');\n    console.log(`Generated ${schema.components.length} components and ${schema.singletons.length} singletons.`);\n    console.log(`Project name: ${projectName}`);\n  };\n}\n"],"names":["formatFiles","joinPathFragments","parseYamlConfig","generateCode","fs","DIRNAME","tree","options","configPath","exists","Error","configContent","read","schema","projectName","outputDir","templateDir","fileOperations","writeFile","path","content","write","readFile","readFileSync","joinPath","segments","accessSync","constants","F_OK","readDir","readdirSync","isDirectory","statSync","console","log","components","length","singletons"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAAeA,WAAW,EAAEC,iBAAiB,QAAQ,aAAa;AAClE,SAASC,eAAe,QAAQ,cAAc;AAC9C,SAASC,YAAY,QAAQ,iBAAiB;AAE9C,YAAYC,QAAQ,KAAK;AACzB,SAASC,OAAO,QAAQ,eAAe;AAMvC,eAAe,eAAgBC,IAAU,EAAEC,OAAyB;IAClE,6BAA6B;IAC7B,MAAMC,aAAaD,QAAQC,UAAU;IACrC,IAAI,CAACF,KAAKG,MAAM,CAACD,aAAa;QAC5B,MAAM,IAAIE,MAAM,CAAC,uBAAuB,EAAEF,WAAW,CAAC;IACxD;IAEA,MAAMG,gBAAgBL,KAAKM,IAAI,CAACJ,YAAY;IAC5C,IAAI,CAACG,eAAe,MAAM,IAAID,MAAM,CAAC,sBAAsB,EAAEF,WAAW,CAAC;IAEzE,MAAM,EAAEK,MAAM,EAAEC,WAAW,EAAE,GAAGZ,gBAAgBS,eAAeH;IAE/D,2DAA2D;IAC3D,MAAMO,YAAYd,kBAAkBO,YAAY;IAChD,MAAMQ,cAAcf,kBAAkBI,SAAS,MAAM;IAErD,6CAA6C;IAC7C,MAAMY,iBAAiC;QACrCC,WAAW,CAACC,MAAcC,UAAoBd,KAAKe,KAAK,CAACF,MAAMC;QAC/D,iDAAiD;QACjDE,UAAU,CAACH,OAAiBf,GAAGmB,YAAY,CAACJ,MAAM;QAClDK,UAAU,CAAC,GAAGC,WAAuBxB,qBAAqBwB;QAC1DhB,QAAQ,CAACU;YACP,IAAI;gBACFf,GAAGsB,UAAU,CAACP,MAAMf,GAAGuB,SAAS,CAACC,IAAI;gBACrC,OAAO;YACT,EAAE,UAAM;gBACN,OAAO;YACT;QACF;QACAC,SAAS,CAACV;YACR,IAAI;gBACF,OAAOf,GAAG0B,WAAW,CAACX;YACxB,EAAE,UAAM;gBACN,OAAO,EAAE;YACX;QACF;QACAY,aAAa,CAACZ;YACZ,IAAI;gBACF,OAAOf,GAAG4B,QAAQ,CAACb,MAAMY,WAAW;YACtC,EAAE,UAAM;gBACN,OAAO;YACT;QACF;IACF;IAEA,IAAI,CAACzB,KAAKG,MAAM,CAACM,YAAY;QAC3BT,KAAKe,KAAK,CAACpB,kBAAkBc,WAAW,aAAa;IACvD;IAEA,kDAAkD;IAClD,MAAMZ,aAAa;QACjBU;QACAC;QACAC;QACAC;QACAC;IACF;IAEA,MAAMjB,YAAYM;IAElB,OAAO;QACL2B,QAAQC,GAAG,CAAC;QACZD,QAAQC,GAAG,CAAC,CAAC,UAAU,EAAErB,OAAOsB,UAAU,CAACC,MAAM,CAAC,gBAAgB,EAAEvB,OAAOwB,UAAU,CAACD,MAAM,CAAC,YAAY,CAAC;QAC1GH,QAAQC,GAAG,CAAC,CAAC,cAAc,EAAEpB,YAAY,CAAC;IAC5C;AACF"}

package/dist/parser.js

@@ -0,0 +1,160 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { getTypeSizeBytes, typeStringToFieldType, typeToArrayConstructor } from '@lagless/binary';
+import { parse } from 'yaml';
+export function parseInputFieldType(fieldName, fieldType) {
+    const res = parseFieldType(fieldType);
+    return _extends({
+        name: fieldName
+    }, res, {
+        type: typeStringToFieldType[res.type],
+        byteLength: res.isArray && res.arrayLength ? getTypeSizeBytes(res.type) * res.arrayLength : getTypeSizeBytes(res.type)
+    });
+}
+export function parseFieldType(typeStr) {
+    const arrayMatch = typeStr.match(/^(\w+)\[(\d+)]$/);
+    if (arrayMatch) {
+        const baseType = arrayMatch[1];
+        const arrayLength = parseInt(arrayMatch[2], 10);
+        if (!Object.keys(typeToArrayConstructor).includes(baseType)) {
+            throw new Error(`Unsupported array base type: ${baseType}`);
+        }
+        if (arrayLength <= 0) {
+            throw new Error(`Array length must be positive: ${arrayLength}`);
+        }
+        return {
+            type: baseType,
+            isArray: true,
+            arrayLength
+        };
+    } else {
+        if (!Object.keys(typeToArrayConstructor).includes(typeStr)) {
+            throw new Error(`Unsupported type: ${typeStr}`);
+        }
+        return {
+            type: typeStr,
+            isArray: false
+        };
+    }
+}
+export function getProjectNameFromConfigPath(configPath) {
+    let projectName = configPath.split('/').slice(-5)[0];
+    projectName = projectName.slice(0, 1).toUpperCase() + projectName.slice(1);
+    // kebab to PascalCase
+    projectName = projectName.replace(/-([a-z])/g, (match, letter)=>letter.toUpperCase());
+    return projectName;
+}
+export function parseYamlConfig(configContent, configPath) {
+    const rawConfig = parse(configContent);
+    if (!rawConfig.components && !rawConfig.singletons) {
+        throw new Error('Config must contain at least one of: components, singletons');
+    }
+    // Determine project name: from config or from path
+    let projectName;
+    if (rawConfig.projectName) {
+        projectName = rawConfig.projectName;
+    } else if (configPath) {
+        projectName = getProjectNameFromConfigPath(configPath);
+    } else {
+        throw new Error('projectName must be specified in config or configPath must be provided');
+    }
+    const components = [];
+    const singletons = [];
+    // Parse components
+    let componentIdx = 0;
+    if (rawConfig.components) {
+        for (const [componentName, componentFields] of Object.entries(rawConfig.components)){
+            const fields = {};
+            for (const [fieldName, fieldType] of Object.entries(componentFields)){
+                fields[fieldName] = parseFieldType(fieldType);
+            }
+            components.push({
+                name: componentName,
+                id: Math.pow(2, componentIdx++),
+                fields
+            });
+        }
+    }
+    // Parse singletons
+    if (rawConfig.singletons) {
+        for (const [singletonName, singletonFields] of Object.entries(rawConfig.singletons)){
+            const fields = {};
+            for (const [fieldName, fieldType] of Object.entries(singletonFields)){
+                fields[fieldName] = parseFieldType(fieldType);
+            }
+            singletons.push({
+                name: singletonName,
+                fields
+            });
+        }
+    }
+    const playerResources = new Array();
+    // Parse player resources
+    if (rawConfig.playerResources) {
+        for (const [resourceName, resourceFields] of Object.entries(rawConfig.playerResources)){
+            const fields = {};
+            for (const [fieldName, fieldType] of Object.entries(resourceFields)){
+                fields[fieldName] = parseFieldType(fieldType);
+            }
+            playerResources.push({
+                name: resourceName,
+                fields
+            });
+        }
+    }
+    const filters = new Array();
+    // Parse filters
+    if (rawConfig.filters) {
+        for (const [filterName, filterComponents] of Object.entries(rawConfig.filters)){
+            const include = [];
+            const exclude = [];
+            for (const componentName of filterComponents.include || []){
+                const component = components.find((c)=>c.name === componentName);
+                if (!component) {
+                    throw new Error(`Component not found in schema: ${componentName}`);
+                }
+                include.push(component);
+            }
+            for (const componentName of filterComponents.exclude || []){
+                const component = components.find((c)=>c.name === componentName);
+                if (!component) {
+                    throw new Error(`Component not found in schema: ${componentName}`);
+                }
+                exclude.push(component);
+            }
+            filters.push({
+                name: filterName,
+                include,
+                exclude
+            });
+        }
+    }
+    const inputs = new Array();
+    // Parse inputs
+    if (rawConfig.inputs) {
+        let inputIdx = 1;
+        for (const [inputName, inputFields] of Object.entries(rawConfig.inputs)){
+            const fields = new Array();
+            for (const [fieldName, fieldType] of Object.entries(inputFields)){
+                fields.push(parseInputFieldType(fieldName, fieldType));
+            }
+            inputs.push({
+                name: inputName,
+                id: inputIdx++,
+                fields
+            });
+        }
+    }
+    const schema = {
+        components,
+        singletons,
+        filters,
+        playerResources,
+        inputs
+    };
+    return {
+        schema,
+        projectName
+    };
+}
+
+//# sourceMappingURL=parser.js.map

package/dist/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/parser.ts"],"sourcesContent":["import {\n  getTypeSizeBytes,\n  InputFieldDefinition,\n  typeStringToFieldType,\n  typeToArrayConstructor,\n} from '@lagless/binary';\nimport {\n  ComponentDefinition,\n  ECSSchema,\n  FieldDefinition,\n  FilterDefinition,\n  IInputDefinition,\n  PlayerResourceDefinition,\n  SingletonDefinition,\n} from '@lagless/core';\nimport { parse } from 'yaml';\n\nexport interface ECSConfig {\n  projectName?: string;\n  components?: Record<string, Record<string, string>>;\n  singletons?: Record<string, Record<string, string>>;\n  playerResources?: Record<string, Record<string, string>>;\n  filters?: Record<string, { include?: string[]; exclude?: string[] }>;\n  inputs?: Record<string, Record<string, string>>;\n}\n\nexport function parseInputFieldType(fieldName: string, fieldType: string): InputFieldDefinition {\n  const res = parseFieldType(fieldType);\n\n  return {\n    name: fieldName,\n    ...res,\n    type: typeStringToFieldType[res.type],\n    byteLength: res.isArray && res.arrayLength ? getTypeSizeBytes(res.type) * res.arrayLength : getTypeSizeBytes(res.type),\n  };\n}\n\nexport function parseFieldType(typeStr: string): FieldDefinition {\n  const arrayMatch = typeStr.match(/^(\\w+)\\[(\\d+)]$/);\n  if (arrayMatch) {\n    const baseType = arrayMatch[1];\n    const arrayLength = parseInt(arrayMatch[2], 10);\n\n    if (!Object.keys(typeToArrayConstructor).includes(baseType)) {\n      throw new Error(`Unsupported array base type: ${baseType}`);\n    }\n\n    if (arrayLength <= 0) {\n      throw new Error(`Array length must be positive: ${arrayLength}`);\n    }\n\n    return {\n      type: baseType,\n      isArray: true,\n      arrayLength,\n    };\n  } else {\n    if (!Object.keys(typeToArrayConstructor).includes(typeStr)) {\n      throw new Error(`Unsupported type: ${typeStr}`);\n    }\n\n    return {\n      type: typeStr,\n      isArray: false,\n    };\n  }\n}\n\nexport function getProjectNameFromConfigPath(configPath: string): string {\n  let projectName = configPath.split('/').slice(-5)[0];\n  projectName = projectName.slice(0, 1).toUpperCase() + projectName.slice(1);\n  // kebab to PascalCase\n  projectName = projectName.replace(/-([a-z])/g, (match, letter) => letter.toUpperCase());\n  return projectName;\n}\n\nexport function parseYamlConfig(configContent: string, configPath?: string): { schema: ECSSchema; projectName: string } {\n  const rawConfig = parse(configContent) as ECSConfig;\n\n  if (!rawConfig.components && !rawConfig.singletons) {\n    throw new Error('Config must contain at least one of: components, singletons');\n  }\n\n  // Determine project name: from config or from path\n  let projectName: string;\n  if (rawConfig.projectName) {\n    projectName = rawConfig.projectName;\n  } else if (configPath) {\n    projectName = getProjectNameFromConfigPath(configPath);\n  } else {\n    throw new Error('projectName must be specified in config or configPath must be provided');\n  }\n\n  const components: ComponentDefinition[] = [];\n  const singletons: SingletonDefinition[] = [];\n\n  // Parse components\n  let componentIdx = 0;\n  if (rawConfig.components) {\n    for (const [componentName, componentFields] of Object.entries<Record<string, string>>(rawConfig.components)) {\n      const fields: Record<string, FieldDefinition> = {};\n\n      for (const [fieldName, fieldType] of Object.entries<string>(componentFields)) {\n        fields[fieldName] = parseFieldType(fieldType);\n      }\n\n      components.push({\n        name: componentName,\n        id: Math.pow(2, componentIdx++),\n        fields,\n      });\n    }\n  }\n\n  // Parse singletons\n  if (rawConfig.singletons) {\n    for (const [singletonName, singletonFields] of Object.entries<Record<string, string>>(rawConfig.singletons)) {\n      const fields: Record<string, FieldDefinition> = {};\n\n      for (const [fieldName, fieldType] of Object.entries<string>(singletonFields)) {\n        fields[fieldName] = parseFieldType(fieldType);\n      }\n\n      singletons.push({\n        name: singletonName,\n        fields,\n      });\n    }\n  }\n\n  const playerResources = new Array<PlayerResourceDefinition>();\n  // Parse player resources\n  if (rawConfig.playerResources) {\n    for (const [resourceName, resourceFields] of Object.entries<Record<string, string>>(rawConfig.playerResources)) {\n      const fields: Record<string, FieldDefinition> = {};\n\n      for (const [fieldName, fieldType] of Object.entries<string>(resourceFields)) {\n        fields[fieldName] = parseFieldType(fieldType);\n      }\n\n      playerResources.push({\n        name: resourceName,\n        fields,\n      });\n    }\n  }\n\n  const filters = new Array<FilterDefinition>();\n  // Parse filters\n  if (rawConfig.filters) {\n    for (const [filterName, filterComponents] of Object.entries(rawConfig.filters)) {\n      const include: ComponentDefinition[] = [];\n      const exclude: ComponentDefinition[] = [];\n\n      for (const componentName of filterComponents.include || []) {\n        const component = components.find(c => c.name === componentName);\n        if (!component) {\n          throw new Error(`Component not found in schema: ${componentName}`);\n        }\n        include.push(component);\n      }\n\n      for (const componentName of filterComponents.exclude || []) {\n        const component = components.find(c => c.name === componentName);\n        if (!component) {\n          throw new Error(`Component not found in schema: ${componentName}`);\n        }\n        exclude.push(component);\n      }\n\n      filters.push({\n        name: filterName,\n        include,\n        exclude,\n      });\n    }\n  }\n\n  const inputs = new Array<IInputDefinition>();\n  // Parse inputs\n  if (rawConfig.inputs) {\n    let inputIdx = 1;\n    for (const [inputName, inputFields] of Object.entries<Record<string, string>>(rawConfig.inputs)) {\n      const fields = new Array<InputFieldDefinition>();\n\n      for (const [fieldName, fieldType] of Object.entries<string>(inputFields)) {\n        fields.push(parseInputFieldType(fieldName, fieldType));\n      }\n\n      inputs.push({\n        name: inputName,\n        id: inputIdx++,\n        fields,\n      });\n    }\n  }\n\n  const schema = { components, singletons, filters, playerResources, inputs };\n  return { schema, projectName };\n}\n"],"names":["getTypeSizeBytes","typeStringToFieldType","typeToArrayConstructor","parse","parseInputFieldType","fieldName","fieldType","res","parseFieldType","name","type","byteLength","isArray","arrayLength","typeStr","arrayMatch","match","baseType","parseInt","Object","keys","includes","Error","getProjectNameFromConfigPath","configPath","projectName","split","slice","toUpperCase","replace","letter","parseYamlConfig","configContent","rawConfig","components","singletons","componentIdx","componentName","componentFields","entries","fields","push","id","Math","pow","singletonName","singletonFields","playerResources","Array","resourceName","resourceFields","filters","filterName","filterComponents","include","exclude","component","find","c","inputs","inputIdx","inputName","inputFields","schema"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/template-engine.js

@@ -0,0 +1,149 @@
+import * as ejs from 'ejs';
+export class TemplateEngine {
+    async generateFromTemplate(options) {
+        const { templateDir, outputDir, data } = options;
+        if (!this.fileOps.exists(templateDir)) {
+            throw new Error(`Template directory not found: ${templateDir}`);
+        }
+        // Find all template files
+        const templateFiles = this.findTemplateFiles(templateDir, '');
+        if (templateFiles.length === 0) {
+            throw new Error(`No template files found in: ${templateDir}`);
+        }
+        // Process each template file
+        for (const templateFile of templateFiles){
+            await this.processTemplateFile(templateFile, outputDir, data);
+        }
+    }
+    findTemplateFiles(baseDir, relativePath) {
+        const files = [];
+        const currentDir = this.fileOps.joinPath(baseDir, relativePath);
+        if (!this.fileOps.exists(currentDir)) {
+            return files;
+        }
+        // If we have readDir and isDirectory, use them for proper directory traversal
+        if (this.fileOps.readDir && this.fileOps.isDirectory) {
+            try {
+                const entries = this.fileOps.readDir(currentDir);
+                for (const entry of entries){
+                    const entryPath = this.fileOps.joinPath(currentDir, entry);
+                    const entryRelativePath = relativePath ? this.fileOps.joinPath(relativePath, entry) : entry;
+                    if (this.fileOps.isDirectory(entryPath)) {
+                        // Recursively process subdirectories
+                        files.push(...this.findTemplateFiles(baseDir, entryRelativePath));
+                    } else if (this.isTemplateFile(entry)) {
+                        files.push({
+                            fullPath: entryPath,
+                            relativePath: entryRelativePath,
+                            outputPath: this.getOutputPath(entryRelativePath)
+                        });
+                    }
+                }
+            } catch (error) {
+                console.warn(`Could not read directory ${currentDir}:`, error);
+            }
+        } else {
+            // Fallback: check for common template file patterns
+            const commonFiles = [
+                'index.ts.ejs',
+                'index.ts',
+                '__name__.ts.ejs',
+                '__name__.ts',
+                '__projectName__.ts.ejs',
+                '__projectName__.ts',
+                'template.ts.ejs',
+                'template.ts'
+            ];
+            for (const fileName of commonFiles){
+                const fullPath = this.fileOps.joinPath(currentDir, fileName);
+                if (this.fileOps.exists(fullPath)) {
+                    const fileRelativePath = relativePath ? this.fileOps.joinPath(relativePath, fileName) : fileName;
+                    files.push({
+                        fullPath,
+                        relativePath: fileRelativePath,
+                        outputPath: this.getOutputPath(fileRelativePath)
+                    });
+                }
+            }
+        }
+        return files;
+    }
+    isTemplateFile(fileName) {
+        // Consider files as templates if they:
+        // 1. Have .ejs extension
+        // 2. Are common code file extensions (.ts, .js, .json, etc.)
+        // 3. Contain template variables in filename
+        const templateExtensions = [
+            '.ejs',
+            '.ts',
+            '.js',
+            '.json',
+            '.md',
+            '.txt',
+            '.html'
+        ];
+        const hasTemplateExtension = templateExtensions.some((ext)=>fileName.endsWith(ext));
+        const hasTemplateVariables = fileName.includes('__') || fileName.includes('<%');
+        return hasTemplateExtension || hasTemplateVariables;
+    }
+    getOutputPath(relativePath) {
+        let outputPath = relativePath;
+        // extension should be always .ts
+        // if ends with .template, just remove it
+        if (outputPath.endsWith('.template')) {
+            outputPath = outputPath.slice(0, -'.template'.length);
+        }
+        return outputPath;
+    }
+    async processTemplateFile(templateFile, outputDir, data) {
+        try {
+            // Read template content
+            const templateContent = this.fileOps.readFile(templateFile.fullPath);
+            // Process filename with template variables
+            let outputFileName = templateFile.outputPath;
+            if (outputFileName.includes('__') || outputFileName.includes('<%')) {
+                outputFileName = this.processFileName(outputFileName, data);
+            }
+            // Render template content
+            const renderedContent = ejs.render(templateContent, data, {
+                filename: templateFile.fullPath,
+                rmWhitespace: false,
+                delimiter: '%'
+            });
+            // Write output file
+            const outputPath = this.fileOps.joinPath(outputDir, outputFileName);
+            this.fileOps.writeFile(outputPath, renderedContent);
+            console.log(`Generated: ${outputFileName}`);
+        } catch (error) {
+            throw new Error(`Failed to process template ${templateFile.relativePath}: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    processFileName(fileName, data) {
+        let result = fileName;
+        // Handle __variable__ pattern
+        result = result.replace(/__(\w+)__/g, (match, varName)=>{
+            return data[varName] || match;
+        });
+        // Handle EJS pattern <%= variable %>
+        if (result.includes('<%')) {
+            try {
+                result = ejs.render(result, data, {
+                    delimiter: '%'
+                });
+            } catch (error) {
+                console.warn(`Could not process filename template: ${fileName}`, error);
+            }
+        }
+        return result;
+    }
+    constructor(fileOperations){
+        this.fileOps = fileOperations;
+    }
+}
+// Helper function for easier usage
+export function generateFromTemplate(options) {
+    const engine = new TemplateEngine(options.fileOperations);
+    return engine.generateFromTemplate(options);
+}
+
+//# sourceMappingURL=template-engine.js.map

package/dist/template-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/template-engine.ts"],"sourcesContent":["import * as ejs from 'ejs';\n\nexport interface FileOperations {\n  readFile: (path: string) => string;\n  writeFile: (path: string, content: string) => void;\n  joinPath: (...segments: string[]) => string;\n  exists: (path: string) => boolean;\n  readDir?: (path: string) => string[];\n  isDirectory?: (path: string) => boolean;\n}\n\nexport interface TemplateOptions {\n  templateDir: string;\n  outputDir: string;\n  data: any;\n  fileOperations: FileOperations;\n}\n\nexport interface TemplateFile {\n  fullPath: string;\n  relativePath: string;\n  outputPath: string;\n}\n\nexport class TemplateEngine {\n  private fileOps: FileOperations;\n\n  constructor(fileOperations: FileOperations) {\n    this.fileOps = fileOperations;\n  }\n\n  async generateFromTemplate(options: TemplateOptions): Promise<void> {\n    const { templateDir, outputDir, data } = options;\n\n    if (!this.fileOps.exists(templateDir)) {\n      throw new Error(`Template directory not found: ${templateDir}`);\n    }\n\n    // Find all template files\n    const templateFiles = this.findTemplateFiles(templateDir, '');\n\n    if (templateFiles.length === 0) {\n      throw new Error(`No template files found in: ${templateDir}`);\n    }\n\n    // Process each template file\n    for (const templateFile of templateFiles) {\n      await this.processTemplateFile(templateFile, outputDir, data);\n    }\n  }\n\n  private findTemplateFiles(baseDir: string, relativePath: string): TemplateFile[] {\n    const files: TemplateFile[] = [];\n    const currentDir = this.fileOps.joinPath(baseDir, relativePath);\n\n    if (!this.fileOps.exists(currentDir)) {\n      return files;\n    }\n\n    // If we have readDir and isDirectory, use them for proper directory traversal\n    if (this.fileOps.readDir && this.fileOps.isDirectory) {\n      try {\n        const entries = this.fileOps.readDir(currentDir);\n\n        for (const entry of entries) {\n          const entryPath = this.fileOps.joinPath(currentDir, entry);\n          const entryRelativePath = relativePath ? this.fileOps.joinPath(relativePath, entry) : entry;\n\n          if (this.fileOps.isDirectory(entryPath)) {\n            // Recursively process subdirectories\n            files.push(...this.findTemplateFiles(baseDir, entryRelativePath));\n          } else if (this.isTemplateFile(entry)) {\n            files.push({\n              fullPath: entryPath,\n              relativePath: entryRelativePath,\n              outputPath: this.getOutputPath(entryRelativePath),\n            });\n          }\n        }\n      } catch (error) {\n        console.warn(`Could not read directory ${currentDir}:`, error);\n      }\n    } else {\n      // Fallback: check for common template file patterns\n      const commonFiles = [\n        'index.ts.ejs',\n        'index.ts',\n        '__name__.ts.ejs',\n        '__name__.ts',\n        '__projectName__.ts.ejs',\n        '__projectName__.ts',\n        'template.ts.ejs',\n        'template.ts',\n      ];\n\n      for (const fileName of commonFiles) {\n        const fullPath = this.fileOps.joinPath(currentDir, fileName);\n        if (this.fileOps.exists(fullPath)) {\n          const fileRelativePath = relativePath ? this.fileOps.joinPath(relativePath, fileName) : fileName;\n          files.push({\n            fullPath,\n            relativePath: fileRelativePath,\n            outputPath: this.getOutputPath(fileRelativePath),\n          });\n        }\n      }\n    }\n\n    return files;\n  }\n\n  private isTemplateFile(fileName: string): boolean {\n    // Consider files as templates if they:\n    // 1. Have .ejs extension\n    // 2. Are common code file extensions (.ts, .js, .json, etc.)\n    // 3. Contain template variables in filename\n    const templateExtensions = ['.ejs', '.ts', '.js', '.json', '.md', '.txt', '.html'];\n    const hasTemplateExtension = templateExtensions.some(ext => fileName.endsWith(ext));\n    const hasTemplateVariables = fileName.includes('__') || fileName.includes('<%');\n\n    return hasTemplateExtension || hasTemplateVariables;\n  }\n\n  private getOutputPath(relativePath: string): string {\n    let outputPath = relativePath;\n\n    // extension should be always .ts\n    // if ends with .template, just remove it\n\n    if (outputPath.endsWith('.template')) {\n      outputPath = outputPath.slice(0, -'.template'.length);\n    }\n\n    return outputPath;\n  }\n\n  private async processTemplateFile(templateFile: TemplateFile, outputDir: string, data: any): Promise<void> {\n    try {\n      // Read template content\n      const templateContent = this.fileOps.readFile(templateFile.fullPath);\n\n      // Process filename with template variables\n      let outputFileName = templateFile.outputPath;\n      if (outputFileName.includes('__') || outputFileName.includes('<%')) {\n        outputFileName = this.processFileName(outputFileName, data);\n      }\n\n      // Render template content\n      const renderedContent = ejs.render(templateContent, data, {\n        filename: templateFile.fullPath,\n        rmWhitespace: false,\n        delimiter: '%',\n      });\n\n      // Write output file\n      const outputPath = this.fileOps.joinPath(outputDir, outputFileName);\n      this.fileOps.writeFile(outputPath, renderedContent);\n\n      console.log(`Generated: ${outputFileName}`);\n\n    } catch (error) {\n      throw new Error(`Failed to process template ${templateFile.relativePath}: ${error instanceof Error ? error.message : error}`);\n    }\n  }\n\n  private processFileName(fileName: string, data: any): string {\n    let result = fileName;\n\n    // Handle __variable__ pattern\n    result = result.replace(/__(\\w+)__/g, (match, varName) => {\n      return data[varName] || match;\n    });\n\n    // Handle EJS pattern <%= variable %>\n    if (result.includes('<%')) {\n      try {\n        result = ejs.render(result, data, { delimiter: '%' });\n      } catch (error) {\n        console.warn(`Could not process filename template: ${fileName}`, error);\n      }\n    }\n\n    return result;\n  }\n}\n\n// Helper function for easier usage\nexport function generateFromTemplate(options: TemplateOptions): Promise<void> {\n  const engine = new TemplateEngine(options.fileOperations);\n  return engine.generateFromTemplate(options);\n}\n"],"names":["ejs","TemplateEngine","generateFromTemplate","options","templateDir","outputDir","data","fileOps","exists","Error","templateFiles","findTemplateFiles","length","templateFile","processTemplateFile","baseDir","relativePath","files","currentDir","joinPath","readDir","isDirectory","entries","entry","entryPath","entryRelativePath","push","isTemplateFile","fullPath","outputPath","getOutputPath","error","console","warn","commonFiles","fileName","fileRelativePath","templateExtensions","hasTemplateExtension","some","ext","endsWith","hasTemplateVariables","includes","slice","templateContent","readFile","outputFileName","processFileName","renderedContent","render","filename","rmWhitespace","delimiter","writeFile","log","message","result","replace","match","varName","constructor","fileOperations","engine"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.9.3"}

package/files/component/__name__.ts.template

@@ -0,0 +1,65 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { MemoryTracker } from '@lagless/binary';
+
+export class <%= component.name %> {
+  public static readonly ID = <%= component.id %>;
+  public static readonly schema = {
+  <% for (const [fieldName, field] of Object.entries(fields)) { %>
+    <%= fieldName %>: <%= typeToArrayConstructor[field.type].name %>,
+  <% } %>
+  };
+
+  public readonly unsafe = {} as {
+  <% for (const [fieldName, field] of Object.entries(fields)) { %>
+    <%= fieldName %>: <%= typeToArrayConstructor[field.type].name %>;
+  <% } %>
+  };
+
+  private _cursorIndex = 0;
+  private readonly _cursor: {
+    readonly entity: number;
+    <% for (const [fieldName, field] of Object.entries(fields)) { %>
+    <%= fieldName %>: number;
+    <% } %>
+  };
+
+  public getCursor(index: number) {
+    this._cursorIndex = index;
+    return this._cursor;
+  }
+
+  constructor(maxEntities: number, buffer: ArrayBuffer, memTracker: MemoryTracker) {
+    for (const [fieldName, TypedArrayConstructor] of Object.entries(<%= component.name %>.schema)) {
+      const typedArray = new TypedArrayConstructor(buffer, memTracker.ptr, maxEntities);
+      this.unsafe[fieldName as keyof typeof <%= component.name %>.schema] = typedArray as <%= component.name %>['unsafe'][keyof <%= component.name %>['unsafe']];
+      memTracker.add(typedArray.byteLength);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+
+    this._cursor = {
+      get entity(): number {
+        return self._cursorIndex;
+      },
+
+      <% for (const [fieldName, field] of Object.entries(fields)) { %>
+        get <%= fieldName %>(): number {
+          return self.unsafe.<%= fieldName %>[self._cursorIndex];
+        },
+
+        set <%= fieldName %>(value: number) {
+          self.unsafe.<%= fieldName %>[self._cursorIndex] = value;
+        },
+      <% } %>
+    };
+  }
+
+  public static calculateSize(maxEntities: number, memTracker: MemoryTracker): void {
+    for (const [, TypedArrayConstructor] of Object.entries(this.schema)) {
+      memTracker.add(maxEntities * TypedArrayConstructor.BYTES_PER_ELEMENT);
+    }
+  }
+}
+
+Object.defineProperty(<%= component.name %>, 'name', { value: '<%= component.name %>' });

package/files/core/__projectName__.core.ts.template

@@ -0,0 +1,16 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { ECSDeps } from '@lagless/core';
+
+<% for (const component of schema.components) { %>import { <%= component.name %> } from './<%= component.name %>.js';<% } %>
+<% for (const singleton of schema.singletons) { %>import { <%= singleton.name %> } from './<%= singleton.name %>.js';<% } %>
+<% for (const playerResource of schema.playerResources) { %>import { <%= playerResource.name %> } from './<%= playerResource.name %>.js';<% } %>
+<% for (const filter of schema.filters) { %>import { <%= filter.name %> } from './<%= filter.name %>.js';<% } %>
+<% for (const input of schema.inputs) { %>import { <%= input.name %> } from './<%= input.name %>.js';<% } %>
+
+export const <%= projectName %>Core: ECSDeps = {
+  components: [ <%= schema.components.map(({ name }) => name).join(', ') %> ],
+  singletons: [ <%= schema.singletons.map(({ name }) => name).join(', ') %> ],
+  playerResources: [ <%= schema.playerResources.map(({ name }) => name).join(', ') %> ],
+  filters: [ <%= schema.filters.map(({ name }) => name).join(', ') %> ],
+  inputs: [ <%= schema.inputs.map(({ name }) => name).join(', ') %> ],
+}

package/files/filter/__name__.ts.template

@@ -0,0 +1,13 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { AbstractFilter, IComponentConstructor } from '@lagless/core';
+<% for (const importComponent of componentsImports ) { %>import { <%= importComponent %> } from './<%= importComponent %>.js';<% } %>
+
+export class <%= filter.name %> extends AbstractFilter {
+  public static readonly include: Array<IComponentConstructor> = [<%= filter.include.map(({ name }) => name).join(',') %>];
+  public static readonly exclude: Array<IComponentConstructor> = [<%= filter.exclude.map(({ name }) => name).join(',') %>];
+
+  public readonly includeMask: number = <%= includeMask %>;
+  public readonly excludeMask: number = <%= excludeMask %>;
+}
+
+Object.defineProperty(<%= filter.name %>, 'name', { value: '<%= filter.name %>' });

package/files/input/__name__.ts.template

@@ -0,0 +1,33 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { FieldType } from '@lagless/binary';
+
+export class <%= input.name %> {
+  public static readonly id = <%= input.id %>;
+  public readonly id = <%= input.id %>;
+
+  <% let totalByteLength = input.fields.reduce((acc, field) => acc + field.byteLength, 0); %>
+
+  // <%= input.fields.map((field) => field.byteLength).join(' + ') %> = <%= totalByteLength %>;
+  public readonly byteLength = <%= totalByteLength %>;
+
+  public readonly fields = [
+    <% for (const field of input.fields) { %>
+    <% if (field.isArray) { %>
+    { name: '<%= field.name %>', type: FieldType.<%= FieldTypeReverse[field.type] %>, isArray: true, arrayLength: <%= field.arrayLength %>, byteLength: <%= field.byteLength %> },
+    <% } else { %>
+    { name: '<%= field.name %>', type: FieldType.<%= FieldTypeReverse[field.type] %>, isArray: false, byteLength: <%= field.byteLength %> },
+    <% } %>
+    <% } %>
+  ] as const;
+
+  public readonly schema!: {
+    <% for (const field of input.fields) { %>
+    <% if (field.isArray) { %>
+    <%= field.name %>: <%= typedArrayConstructors[field.type].name %>,
+    <% } else { %>
+    <%= field.name %>: number,
+    <% } %>
+    <% } %>
+  };
+
+}

package/files/input-registry/__projectName__InputRegistry.ts.template

@@ -0,0 +1,9 @@
+// Generated by @lagless/codegen. Do not edit manually.
+import { InputRegistry } from '@lagless/core';
+
+<% for (const input of inputs) { %>import { <%= input.name %> } from './<%= input.name %>.js';<% } %>
+
+
+export const <%= projectName %>InputRegistry = new InputRegistry([
+  <% for (const input of inputs) { %><%= input.name %>,<% } %>
+]);