@player-tools/fluent-generator 0.13.0--canary.221.5819

package/dist/cjs/index.cjs

@@ -0,0 +1,510 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/generators/fluent/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  containsArrayType: () => containsArrayType,
+  extractGenericUsage: () => extractGenericUsage,
+  generateFluentBuilder: () => generateFluentBuilder,
+  getAssetTypeFromExtends: () => getAssetTypeFromExtends,
+  getPropertiesInfo: () => getPropertiesInfo,
+  isAndType: () => import_xlr_utils.isAndType,
+  isArrayType: () => import_xlr_utils.isArrayType,
+  isAssetWrapperRef: () => isAssetWrapperRef,
+  isBindingRef: () => isBindingRef,
+  isBooleanType: () => import_xlr_utils.isBooleanType,
+  isComplexObjectType: () => isComplexObjectType,
+  isExpressionRef: () => isExpressionRef,
+  isNamedType: () => import_xlr_utils.isNamedType,
+  isNumberType: () => import_xlr_utils.isNumberType,
+  isObjectType: () => import_xlr_utils.isObjectType,
+  isOrType: () => import_xlr_utils.isOrType,
+  isPrimitiveConst: () => isPrimitiveConst,
+  isRecordType: () => import_xlr_utils.isRecordType,
+  isRefType: () => import_xlr_utils.isRefType,
+  isStringType: () => import_xlr_utils.isStringType,
+  toBuilderClassName: () => toBuilderClassName,
+  toFactoryName: () => toFactoryName,
+  toPascalCase: () => toPascalCase
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/generators/fluent/src/generator.ts
+var import_xlr_utils2 = require("@player-tools/xlr-utils");
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/generators/fluent/src/utils.ts
+var import_xlr_utils = require("@player-tools/xlr-utils");
+function isPrimitiveConst(node) {
+  return ((0, import_xlr_utils.isStringType)(node) || (0, import_xlr_utils.isNumberType)(node) || (0, import_xlr_utils.isBooleanType)(node)) && "const" in node && node.const !== void 0;
+}
+function isAssetWrapperRef(node) {
+  return (0, import_xlr_utils.isRefType)(node) && node.ref.startsWith("AssetWrapper");
+}
+function isExpressionRef(node) {
+  return (0, import_xlr_utils.isRefType)(node) && node.ref === "Expression";
+}
+function isBindingRef(node) {
+  return (0, import_xlr_utils.isRefType)(node) && node.ref === "Binding";
+}
+function toPascalCase(str) {
+  return str.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function toFactoryName(typeName) {
+  const name = typeName.replace(/Asset$/, "");
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function toBuilderClassName(typeName) {
+  return `${typeName}Builder`;
+}
+function isComplexObjectType(obj) {
+  const props = Object.values(obj.properties);
+  const hasSlots = props.some((p) => isAssetWrapperRef(p.node));
+  if (hasSlots) return true;
+  if (props.length > 3) return true;
+  const hasNestedObjects = props.some(
+    (p) => (0, import_xlr_utils.isObjectType)(p.node) && !isPrimitiveConst(p.node)
+  );
+  if (hasNestedObjects) return true;
+  return false;
+}
+function getAssetTypeFromExtends(obj) {
+  if (!obj.extends) return void 0;
+  const ref = obj.extends;
+  if (ref.genericArguments && ref.genericArguments.length > 0) {
+    const typeArg = ref.genericArguments[0];
+    if ((0, import_xlr_utils.isStringType)(typeArg) && typeArg.const) {
+      return typeArg.const;
+    }
+  }
+  return void 0;
+}
+function getPropertiesInfo(obj) {
+  return Object.entries(obj.properties).map(([name, prop]) => {
+    const isSlot = isAssetWrapperRef(prop.node);
+    const isArray = (0, import_xlr_utils.isArrayType)(prop.node);
+    const isArraySlot = isArray && isAssetWrapperRef(prop.node.elementType);
+    return {
+      name,
+      node: prop.node,
+      required: prop.required,
+      isSlot,
+      isArraySlot,
+      isArray
+    };
+  });
+}
+function containsArrayType(node) {
+  if ((0, import_xlr_utils.isArrayType)(node)) {
+    return true;
+  }
+  if ((0, import_xlr_utils.isOrType)(node)) {
+    return node.or.some(containsArrayType);
+  }
+  if ((0, import_xlr_utils.isAndType)(node)) {
+    return node.and.some(containsArrayType);
+  }
+  return false;
+}
+function extractGenericUsage(genericParams) {
+  if (!genericParams) {
+    return "";
+  }
+  const params = genericParams.split(",").map((p) => p.trim().split(" ")[0]).join(", ");
+  return `<${params}>`;
+}
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/generators/fluent/src/generator.ts
+function extractBaseName(ref) {
+  const bracketIndex = ref.indexOf("<");
+  return bracketIndex === -1 ? ref : ref.substring(0, bracketIndex);
+}
+var FluentBuilderGenerator = class {
+  namedType;
+  config;
+  /** Track nested types that need their own builders */
+  nestedBuilders = /* @__PURE__ */ new Map();
+  /** Track array properties for __arrayProperties__ */
+  arrayProperties = /* @__PURE__ */ new Set();
+  /** Track all type references that need to be imported from the source type file */
+  referencedTypes = /* @__PURE__ */ new Set();
+  /** Track whether Asset type is needed for imports */
+  needsAssetImport = false;
+  constructor(namedType, config = {}) {
+    this.namedType = namedType;
+    this.config = config;
+  }
+  /**
+   * Generate the builder code
+   */
+  generate() {
+    const mainBuilder = this.createBuilderInfo(this.namedType);
+    this.collectNestedTypes(this.namedType);
+    const nestedBuilderCode = Array.from(this.nestedBuilders.entries()).map(([name, objType]) => {
+      const info = {
+        name,
+        className: toBuilderClassName(name),
+        factoryName: toFactoryName(name),
+        objectType: objType,
+        isAsset: false
+      };
+      return this.generateBuilderClass(info);
+    }).join("\n\n");
+    const mainBuilderCode = this.generateBuilderClass(mainBuilder);
+    const imports = this.generateImports(mainBuilder);
+    return [imports, nestedBuilderCode, mainBuilderCode].filter(Boolean).join("\n\n");
+  }
+  createBuilderInfo(namedType) {
+    const assetType = getAssetTypeFromExtends(namedType);
+    const isAsset = !!assetType;
+    let genericParams;
+    if ((0, import_xlr_utils2.isGenericNamedType)(namedType)) {
+      genericParams = namedType.genericTokens.map((t) => {
+        let param = t.symbol;
+        if (t.constraints) {
+          param += ` extends ${this.transformType(t.constraints)}`;
+        }
+        if (t.default) {
+          param += ` = ${this.transformType(t.default)}`;
+        }
+        return param;
+      }).join(", ");
+    }
+    return {
+      name: namedType.name,
+      className: toBuilderClassName(namedType.name),
+      factoryName: toFactoryName(namedType.name),
+      objectType: namedType,
+      assetType,
+      genericParams,
+      isAsset
+    };
+  }
+  generateImports(mainBuilder) {
+    const typeImportPath = this.config.typeImportPathGenerator ? this.config.typeImportPathGenerator(mainBuilder.name) : `../types/${this.getTypeFileName(mainBuilder.name)}`;
+    const typesToImport = /* @__PURE__ */ new Set([mainBuilder.name]);
+    Array.from(this.nestedBuilders.keys()).forEach((name) => {
+      typesToImport.add(name);
+    });
+    Array.from(this.referencedTypes).forEach((name) => {
+      typesToImport.add(name);
+    });
+    const typeImportStatement = `import type { ${Array.from(typesToImport).join(", ")} } from "${typeImportPath}";`;
+    const typesImportPath = this.config.typesImportPath ?? "@player-ui/types";
+    const fluentImportPath = this.config.fluentImportPath ?? "@player-tools/fluent";
+    const lines = [typeImportStatement];
+    if (this.needsAssetImport) {
+      lines.push(`import type { Asset } from "${typesImportPath}";`);
+    }
+    lines.push(
+      `import { type FluentBuilder, type BaseBuildContext, FluentBuilderBase, createInspectMethod, type TaggedTemplateValue } from "${fluentImportPath}";`
+    );
+    return lines.join("\n");
+  }
+  getTypeFileName(typeName) {
+    return typeName.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "").replace(/asset$/, "");
+  }
+  collectNestedTypes(objType) {
+    for (const [propName, prop] of Object.entries(objType.properties)) {
+      this.collectNestedTypesFromNode(prop.node, propName);
+    }
+  }
+  collectNestedTypesFromNode(node, parentName) {
+    if ((0, import_xlr_utils.isObjectType)(node)) {
+      if ((0, import_xlr_utils.isNamedType)(node) && isComplexObjectType(node)) {
+        this.nestedBuilders.set(node.name, node);
+        this.collectNestedTypes(node);
+      } else if (!(0, import_xlr_utils.isNamedType)(node) && isComplexObjectType(node)) {
+        const name = toPascalCase(parentName);
+        this.nestedBuilders.set(name, node);
+        this.collectNestedTypes(node);
+      } else if ((0, import_xlr_utils.isNamedType)(node)) {
+        this.referencedTypes.add(node.name);
+      }
+    } else if ((0, import_xlr_utils.isArrayType)(node)) {
+      this.collectNestedTypesFromNode(node.elementType, parentName);
+    } else if ((0, import_xlr_utils.isOrType)(node)) {
+      for (const variant of node.or) {
+        this.collectNestedTypesFromNode(variant, parentName);
+      }
+    } else if ((0, import_xlr_utils.isAndType)(node)) {
+      for (const part of node.and) {
+        this.collectNestedTypesFromNode(part, parentName);
+      }
+    } else if ((0, import_xlr_utils.isRefType)(node)) {
+      const baseName = extractBaseName(node.ref);
+      const builtInTypes = [
+        "Asset",
+        "AssetWrapper",
+        "Binding",
+        "Expression",
+        "Array",
+        "Record"
+      ];
+      if (!builtInTypes.includes(baseName)) {
+        this.referencedTypes.add(baseName);
+      }
+    }
+  }
+  generateBuilderClass(info) {
+    const {
+      name,
+      className,
+      factoryName,
+      objectType,
+      assetType,
+      genericParams
+    } = info;
+    this.arrayProperties.clear();
+    const genericPart = genericParams ? `<${genericParams}>` : "";
+    const genericUsage = extractGenericUsage(genericParams);
+    const interfaceCode = this.generateInterfaceMethods(info);
+    const classMethods = this.generateClassMethods(info);
+    const defaults = this.generateDefaults(objectType, assetType);
+    const arrayPropsCode = this.arrayProperties.size > 0 ? `  private static readonly __arrayProperties__: ReadonlySet<string> = new Set([${Array.from(
+      this.arrayProperties
+    ).map((p) => `"${p}"`).join(", ")}]);
+` : "";
+    const classCode = `
+${interfaceCode}
+
+/**
+ * A builder for ${name}
+ */
+export class ${className}${genericPart} extends FluentBuilderBase<${name}${genericUsage}> implements ${className}Methods${genericUsage}, FluentBuilder<${name}${genericUsage}, BaseBuildContext> {
+  private static readonly defaults: Record<string, unknown> = ${defaults};
+${arrayPropsCode}
+${classMethods}
+
+  /**
+   * Builds the final ${name} object
+   * @param context - Optional build context for nested builders
+   */
+  build(context?: BaseBuildContext): ${name}${genericUsage} {
+    return this.buildWithDefaults(${className}.defaults, context);
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return createInspectMethod("${className}", this.values);
+  }
+}
+
+/**
+ * Creates a new ${name} builder
+ * @param initial Optional initial values
+ * @returns A fluent builder for ${name}
+ */
+export function ${factoryName}${genericPart}(initial?: Partial<${name}${genericUsage}>): ${className}${genericUsage} {
+  return new ${className}${genericUsage}(initial);
+}`;
+    return classCode.trim();
+  }
+  generateInterfaceMethods(info) {
+    const { className, objectType, genericParams, isAsset } = info;
+    const genericUsage = extractGenericUsage(genericParams);
+    const properties = this.collectPropertiesForMethods(objectType, isAsset);
+    const methods = properties.map(({ propName, propType, description }) => {
+      const methodName = `with${toPascalCase(propName)}`;
+      const paramType = this.transformType(propType, true);
+      return `  /** ${description} */
+  ${methodName}(value: ${paramType}): ${className}${genericUsage};`;
+    }).join("\n");
+    return `export interface ${className}Methods${genericParams ? `<${genericParams}>` : ""} {
+${methods}
+}`;
+  }
+  collectPropertiesForMethods(objectType, isAsset) {
+    const properties = [];
+    if (isAsset) {
+      properties.push({
+        propName: "id",
+        propType: { type: "string" },
+        description: "A unique identifier for this asset"
+      });
+    }
+    for (const [propName, prop] of Object.entries(objectType.properties)) {
+      properties.push({
+        propName,
+        propType: prop.node,
+        description: prop.node.description || `Sets the ${propName} property`
+      });
+    }
+    return properties;
+  }
+  generateClassMethods(info) {
+    const { className, objectType, genericParams, isAsset } = info;
+    const genericUsage = extractGenericUsage(genericParams);
+    const properties = this.collectPropertiesForMethods(objectType, isAsset);
+    return properties.map(({ propName, propType, description }) => {
+      const methodName = `with${toPascalCase(propName)}`;
+      const paramType = this.transformType(propType, true);
+      if (containsArrayType(propType)) {
+        this.arrayProperties.add(propName);
+      }
+      return `  /** ${description} */
+  ${methodName}(value: ${paramType}): ${className}${genericUsage} {
+    return this.set("${propName}", value);
+  }`;
+    }).join("\n\n");
+  }
+  generateDefaults(objectType, assetType) {
+    const defaults = {};
+    if (assetType) {
+      defaults["type"] = assetType;
+    }
+    if (objectType.extends?.ref.startsWith("Asset")) {
+      defaults["id"] = "";
+    } else if ("id" in objectType.properties) {
+      defaults["id"] = "";
+    }
+    for (const [propName, prop] of Object.entries(objectType.properties)) {
+      if (isPrimitiveConst(prop.node)) {
+        defaults[propName] = prop.node.const;
+      }
+    }
+    return JSON.stringify(defaults);
+  }
+  /**
+   * Transform an XLR type to a TypeScript type string
+   * This is the core recursive transformation that adds TaggedTemplateValue support
+   */
+  transformType(node, forParameter = false) {
+    if ((0, import_xlr_utils.isStringType)(node)) {
+      if (isPrimitiveConst(node)) {
+        return `"${node.const}"`;
+      }
+      return forParameter ? "string | TaggedTemplateValue<string>" : "string";
+    }
+    if ((0, import_xlr_utils.isNumberType)(node)) {
+      if (isPrimitiveConst(node)) {
+        return `${node.const}`;
+      }
+      return forParameter ? "number | TaggedTemplateValue<number>" : "number";
+    }
+    if ((0, import_xlr_utils.isBooleanType)(node)) {
+      if (isPrimitiveConst(node)) {
+        return `${node.const}`;
+      }
+      return forParameter ? "boolean | TaggedTemplateValue<boolean>" : "boolean";
+    }
+    if ((0, import_xlr_utils.isRefType)(node)) {
+      return this.transformRefType(node, forParameter);
+    }
+    if ((0, import_xlr_utils.isArrayType)(node)) {
+      const elementType = this.transformType(node.elementType, forParameter);
+      return `Array<${elementType}>`;
+    }
+    if ((0, import_xlr_utils.isOrType)(node)) {
+      const variants = node.or.map((v) => this.transformType(v, forParameter));
+      return variants.join(" | ");
+    }
+    if ((0, import_xlr_utils.isAndType)(node)) {
+      const parts = node.and.map((p) => this.transformType(p, forParameter));
+      return parts.join(" & ");
+    }
+    if ((0, import_xlr_utils.isRecordType)(node)) {
+      const keyType = this.transformType(node.keyType, false);
+      const valueType = this.transformType(node.valueType, forParameter);
+      return `Record<${keyType}, ${valueType}>`;
+    }
+    if ((0, import_xlr_utils.isObjectType)(node)) {
+      if ((0, import_xlr_utils.isNamedType)(node)) {
+        if (isComplexObjectType(node)) {
+          return `${node.name} | FluentBuilder<${node.name}, BaseBuildContext>`;
+        }
+        return node.name;
+      }
+      return this.generateInlineObjectType(node, forParameter);
+    }
+    if (node.type === "null") return "null";
+    if (node.type === "undefined") return "undefined";
+    if (node.type === "any") return "any";
+    if (node.type === "unknown") return "unknown";
+    if (node.type === "never") return "never";
+    if (node.type === "void") return "void";
+    return "unknown";
+  }
+  transformRefType(node, forParameter) {
+    const ref = node.ref;
+    if (ref.startsWith("AssetWrapper")) {
+      this.needsAssetImport = true;
+      return "Asset | FluentBuilder<Asset, BaseBuildContext>";
+    }
+    if (ref === "Expression") {
+      return forParameter ? "string | TaggedTemplateValue<string>" : "string";
+    }
+    if (ref === "Binding") {
+      return forParameter ? "string | TaggedTemplateValue<string>" : "string";
+    }
+    if (ref === "Asset" || ref.startsWith("Asset<")) {
+      this.needsAssetImport = true;
+      return "Asset";
+    }
+    const baseName = extractBaseName(ref);
+    if (this.nestedBuilders.has(baseName)) {
+      return `${baseName} | FluentBuilder<${baseName}, BaseBuildContext>`;
+    }
+    if (node.genericArguments && node.genericArguments.length > 0) {
+      const args = node.genericArguments.map(
+        (a) => this.transformType(a, forParameter)
+      );
+      return `${baseName}<${args.join(", ")}>`;
+    }
+    return baseName;
+  }
+  generateInlineObjectType(node, forParameter) {
+    const props = Object.entries(node.properties).map(([propName, prop]) => {
+      const propType = this.transformType(prop.node, forParameter);
+      const optional = prop.required ? "" : "?";
+      return `${propName}${optional}: ${propType}`;
+    }).join("; ");
+    return `{ ${props} }`;
+  }
+};
+function generateFluentBuilder(namedType, config = {}) {
+  const generator = new FluentBuilderGenerator(namedType, config);
+  return generator.generate();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  containsArrayType,
+  extractGenericUsage,
+  generateFluentBuilder,
+  getAssetTypeFromExtends,
+  getPropertiesInfo,
+  isAndType,
+  isArrayType,
+  isAssetWrapperRef,
+  isBindingRef,
+  isBooleanType,
+  isComplexObjectType,
+  isExpressionRef,
+  isNamedType,
+  isNumberType,
+  isObjectType,
+  isOrType,
+  isPrimitiveConst,
+  isRecordType,
+  isRefType,
+  isStringType,
+  toBuilderClassName,
+  toFactoryName,
+  toPascalCase
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/generators/fluent/src/index.ts","../../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/generators/fluent/src/generator.ts","../../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/generators/fluent/src/utils.ts"],"sourcesContent":["/**\n * @player-tools/fluent-generator\n *\n * Generates fluent builders from XLR types for Player-UI assets.\n */\n\nexport {\n  generateFluentBuilder,\n  type GeneratorConfig,\n  type BuilderInfo,\n} from \"./generator\";\nexport * from \"./utils\";\n","import type {\n  NodeType,\n  ObjectType,\n  RefType,\n  NamedType,\n} from \"@player-tools/xlr\";\nimport { isGenericNamedType } from \"@player-tools/xlr-utils\";\nimport {\n  isStringType,\n  isNumberType,\n  isBooleanType,\n  isObjectType,\n  isArrayType,\n  isRefType,\n  isOrType,\n  isAndType,\n  isRecordType,\n  isNamedType,\n  isPrimitiveConst,\n  toPascalCase,\n  toFactoryName,\n  toBuilderClassName,\n  isComplexObjectType,\n  getAssetTypeFromExtends,\n  containsArrayType,\n  extractGenericUsage,\n} from \"./utils\";\n\n/**\n * Configuration for the generator\n */\nexport interface GeneratorConfig {\n  /** Import path for fluent utilities (default: \"@player-tools/fluent\") */\n  fluentImportPath?: string;\n  /** Import path for player-ui types (default: \"@player-ui/types\") */\n  typesImportPath?: string;\n  /** Function to generate the type import path */\n  typeImportPathGenerator?: (typeName: string) => string;\n}\n\n/**\n * Information about a builder class to generate.\n * Exported for consumers who need to extend or introspect the generator.\n */\nexport interface BuilderInfo {\n  /** Original type name from XLR */\n  name: string;\n  /** Generated class name (e.g., \"TextAssetBuilder\") */\n  className: string;\n  /** Factory function name (e.g., \"text\") */\n  factoryName: string;\n  /** The XLR ObjectType being generated */\n  objectType: ObjectType;\n  /** Asset type string if this is an Asset (e.g., \"text\") */\n  assetType?: string;\n  /** Generic parameters declaration if type is generic */\n  genericParams?: string;\n  /** Whether this type extends Asset */\n  isAsset: boolean;\n}\n\n/**\n * Extracts the base type name from a ref string, handling nested generics.\n * @example\n * extractBaseName(\"MyType\") // \"MyType\"\n * extractBaseName(\"MyType<T>\") // \"MyType\"\n * extractBaseName(\"Map<string, Array<T>>\") // \"Map\"\n */\nfunction extractBaseName(ref: string): string {\n  const bracketIndex = ref.indexOf(\"<\");\n  return bracketIndex === -1 ? ref : ref.substring(0, bracketIndex);\n}\n\n/**\n * Generates fluent builder TypeScript code from XLR types\n */\nexport class FluentBuilderGenerator {\n  private readonly namedType: NamedType<ObjectType>;\n  private readonly config: GeneratorConfig;\n\n  /** Track nested types that need their own builders */\n  private nestedBuilders = new Map<string, ObjectType>();\n\n  /** Track array properties for __arrayProperties__ */\n  private arrayProperties = new Set<string>();\n\n  /** Track all type references that need to be imported from the source type file */\n  private referencedTypes = new Set<string>();\n\n  /** Track whether Asset type is needed for imports */\n  private needsAssetImport = false;\n\n  constructor(namedType: NamedType<ObjectType>, config: GeneratorConfig = {}) {\n    this.namedType = namedType;\n    this.config = config;\n  }\n\n  /**\n   * Generate the builder code\n   */\n  generate(): string {\n    const mainBuilder = this.createBuilderInfo(this.namedType);\n\n    // Collect all nested types that need builders\n    this.collectNestedTypes(this.namedType);\n\n    // Generate nested builder classes first (this sets needsAssetImport flag)\n    const nestedBuilderCode = Array.from(this.nestedBuilders.entries())\n      .map(([name, objType]) => {\n        const info: BuilderInfo = {\n          name,\n          className: toBuilderClassName(name),\n          factoryName: toFactoryName(name),\n          objectType: objType,\n          isAsset: false,\n        };\n        return this.generateBuilderClass(info);\n      })\n      .join(\"\\n\\n\");\n\n    // Generate main builder class (this also sets needsAssetImport flag)\n    const mainBuilderCode = this.generateBuilderClass(mainBuilder);\n\n    // Generate imports after builder code so we know what imports are needed\n    const imports = this.generateImports(mainBuilder);\n\n    return [imports, nestedBuilderCode, mainBuilderCode]\n      .filter(Boolean)\n      .join(\"\\n\\n\");\n  }\n\n  private createBuilderInfo(namedType: NamedType<ObjectType>): BuilderInfo {\n    const assetType = getAssetTypeFromExtends(namedType);\n    const isAsset = !!assetType;\n\n    let genericParams: string | undefined;\n    if (isGenericNamedType(namedType)) {\n      genericParams = namedType.genericTokens\n        .map((t) => {\n          let param = t.symbol;\n          if (t.constraints) {\n            param += ` extends ${this.transformType(t.constraints)}`;\n          }\n          if (t.default) {\n            param += ` = ${this.transformType(t.default)}`;\n          }\n          return param;\n        })\n        .join(\", \");\n    }\n\n    return {\n      name: namedType.name,\n      className: toBuilderClassName(namedType.name),\n      factoryName: toFactoryName(namedType.name),\n      objectType: namedType,\n      assetType,\n      genericParams,\n      isAsset,\n    };\n  }\n\n  private generateImports(mainBuilder: BuilderInfo): string {\n    // Import the main type - use custom generator if provided\n    const typeImportPath = this.config.typeImportPathGenerator\n      ? this.config.typeImportPathGenerator(mainBuilder.name)\n      : `../types/${this.getTypeFileName(mainBuilder.name)}`;\n\n    // Collect all types to import from the same source file\n    // This includes: main type, nested builder types, and other referenced types\n    const typesToImport = new Set<string>([mainBuilder.name]);\n\n    // Add all nested builder types\n    Array.from(this.nestedBuilders.keys()).forEach((name) => {\n      typesToImport.add(name);\n    });\n\n    // Add all referenced types\n    Array.from(this.referencedTypes).forEach((name) => {\n      typesToImport.add(name);\n    });\n\n    const typeImportStatement = `import type { ${Array.from(typesToImport).join(\", \")} } from \"${typeImportPath}\";`;\n\n    // Get import paths from config or use defaults\n    const typesImportPath = this.config.typesImportPath ?? \"@player-ui/types\";\n    const fluentImportPath =\n      this.config.fluentImportPath ?? \"@player-tools/fluent\";\n\n    // Build import lines\n    const lines = [typeImportStatement];\n\n    // Only import Asset if it's used\n    if (this.needsAssetImport) {\n      lines.push(`import type { Asset } from \"${typesImportPath}\";`);\n    }\n\n    lines.push(\n      `import { type FluentBuilder, type BaseBuildContext, FluentBuilderBase, createInspectMethod, type TaggedTemplateValue } from \"${fluentImportPath}\";`,\n    );\n\n    return lines.join(\"\\n\");\n  }\n\n  private getTypeFileName(typeName: string): string {\n    // Convert PascalCase to kebab-case for file name\n    return typeName\n      .replace(/([A-Z])/g, \"-$1\")\n      .toLowerCase()\n      .replace(/^-/, \"\")\n      .replace(/asset$/, \"\");\n  }\n\n  private collectNestedTypes(objType: ObjectType): void {\n    for (const [propName, prop] of Object.entries(objType.properties)) {\n      this.collectNestedTypesFromNode(prop.node, propName);\n    }\n  }\n\n  private collectNestedTypesFromNode(node: NodeType, parentName: string): void {\n    if (isObjectType(node)) {\n      if (isNamedType(node) && isComplexObjectType(node)) {\n        this.nestedBuilders.set(node.name, node);\n        this.collectNestedTypes(node);\n      } else if (!isNamedType(node) && isComplexObjectType(node)) {\n        // Anonymous complex object - generate a builder for it\n        const name = toPascalCase(parentName);\n        this.nestedBuilders.set(name, node);\n        this.collectNestedTypes(node);\n      } else if (isNamedType(node)) {\n        // Simple named type - just track for import\n        this.referencedTypes.add(node.name);\n      }\n    } else if (isArrayType(node)) {\n      this.collectNestedTypesFromNode(node.elementType, parentName);\n    } else if (isOrType(node)) {\n      for (const variant of node.or) {\n        this.collectNestedTypesFromNode(variant, parentName);\n      }\n    } else if (isAndType(node)) {\n      for (const part of node.and) {\n        this.collectNestedTypesFromNode(part, parentName);\n      }\n    } else if (isRefType(node)) {\n      // Track reference types that aren't built-in Player types\n      const baseName = extractBaseName(node.ref);\n      const builtInTypes = [\n        \"Asset\",\n        \"AssetWrapper\",\n        \"Binding\",\n        \"Expression\",\n        \"Array\",\n        \"Record\",\n      ];\n      if (!builtInTypes.includes(baseName)) {\n        this.referencedTypes.add(baseName);\n      }\n    }\n  }\n\n  private generateBuilderClass(info: BuilderInfo): string {\n    const {\n      name,\n      className,\n      factoryName,\n      objectType,\n      assetType,\n      genericParams,\n    } = info;\n\n    // Reset array properties for this builder\n    this.arrayProperties.clear();\n\n    const genericPart = genericParams ? `<${genericParams}>` : \"\";\n    const genericUsage = extractGenericUsage(genericParams);\n\n    // Generate interface methods\n    const interfaceCode = this.generateInterfaceMethods(info);\n\n    // Generate class methods\n    const classMethods = this.generateClassMethods(info);\n\n    // Generate defaults\n    const defaults = this.generateDefaults(objectType, assetType);\n\n    // Generate array properties metadata\n    const arrayPropsCode =\n      this.arrayProperties.size > 0\n        ? `  private static readonly __arrayProperties__: ReadonlySet<string> = new Set([${Array.from(\n            this.arrayProperties,\n          )\n            .map((p) => `\"${p}\"`)\n            .join(\", \")}]);\\n`\n        : \"\";\n\n    // Build the class\n    const classCode = `\n${interfaceCode}\n\n/**\n * A builder for ${name}\n */\nexport class ${className}${genericPart} extends FluentBuilderBase<${name}${genericUsage}> implements ${className}Methods${genericUsage}, FluentBuilder<${name}${genericUsage}, BaseBuildContext> {\n  private static readonly defaults: Record<string, unknown> = ${defaults};\n${arrayPropsCode}\n${classMethods}\n\n  /**\n   * Builds the final ${name} object\n   * @param context - Optional build context for nested builders\n   */\n  build(context?: BaseBuildContext): ${name}${genericUsage} {\n    return this.buildWithDefaults(${className}.defaults, context);\n  }\n\n  [Symbol.for(\"nodejs.util.inspect.custom\")](): string {\n    return createInspectMethod(\"${className}\", this.values);\n  }\n}\n\n/**\n * Creates a new ${name} builder\n * @param initial Optional initial values\n * @returns A fluent builder for ${name}\n */\nexport function ${factoryName}${genericPart}(initial?: Partial<${name}${genericUsage}>): ${className}${genericUsage} {\n  return new ${className}${genericUsage}(initial);\n}`;\n\n    return classCode.trim();\n  }\n\n  private generateInterfaceMethods(info: BuilderInfo): string {\n    const { className, objectType, genericParams, isAsset } = info;\n    const genericUsage = extractGenericUsage(genericParams);\n\n    // Collect all properties to generate methods for\n    const properties = this.collectPropertiesForMethods(objectType, isAsset);\n\n    const methods = properties\n      .map(({ propName, propType, description }) => {\n        const methodName = `with${toPascalCase(propName)}`;\n        const paramType = this.transformType(propType, true);\n\n        return `  /** ${description} */\n  ${methodName}(value: ${paramType}): ${className}${genericUsage};`;\n      })\n      .join(\"\\n\");\n\n    return `export interface ${className}Methods${genericParams ? `<${genericParams}>` : \"\"} {\n${methods}\n}`;\n  }\n\n  private collectPropertiesForMethods(\n    objectType: ObjectType,\n    isAsset: boolean,\n  ): Array<{ propName: string; propType: NodeType; description: string }> {\n    const properties: Array<{\n      propName: string;\n      propType: NodeType;\n      description: string;\n    }> = [];\n\n    // Add inherited Asset properties for asset types\n    if (isAsset) {\n      // Add id property - all assets have an id\n      properties.push({\n        propName: \"id\",\n        propType: { type: \"string\" },\n        description: \"A unique identifier for this asset\",\n      });\n    }\n\n    // Add properties from the object type\n    for (const [propName, prop] of Object.entries(objectType.properties)) {\n      properties.push({\n        propName,\n        propType: prop.node,\n        description: prop.node.description || `Sets the ${propName} property`,\n      });\n    }\n\n    return properties;\n  }\n\n  private generateClassMethods(info: BuilderInfo): string {\n    const { className, objectType, genericParams, isAsset } = info;\n    const genericUsage = extractGenericUsage(genericParams);\n\n    // Collect all properties to generate methods for\n    const properties = this.collectPropertiesForMethods(objectType, isAsset);\n\n    return properties\n      .map(({ propName, propType, description }) => {\n        const methodName = `with${toPascalCase(propName)}`;\n        const paramType = this.transformType(propType, true);\n\n        // Track array properties (including union types that contain arrays)\n        if (containsArrayType(propType)) {\n          this.arrayProperties.add(propName);\n        }\n\n        return `  /** ${description} */\n  ${methodName}(value: ${paramType}): ${className}${genericUsage} {\n    return this.set(\"${propName}\", value);\n  }`;\n      })\n      .join(\"\\n\\n\");\n  }\n\n  private generateDefaults(objectType: ObjectType, assetType?: string): string {\n    const defaults: Record<string, unknown> = {};\n\n    // Add asset type default if this is an asset\n    if (assetType) {\n      defaults[\"type\"] = assetType;\n    }\n\n    // Add default ID for assets (types that extend Asset)\n    if (objectType.extends?.ref.startsWith(\"Asset\")) {\n      defaults[\"id\"] = \"\";\n    }\n    // Also add default ID for non-Asset types that have an 'id' property\n    // This enables ID auto-generation for nested object types\n    else if (\"id\" in objectType.properties) {\n      defaults[\"id\"] = \"\";\n    }\n\n    // Add const defaults from properties\n    for (const [propName, prop] of Object.entries(objectType.properties)) {\n      if (isPrimitiveConst(prop.node)) {\n        defaults[propName] = prop.node.const;\n      }\n    }\n\n    return JSON.stringify(defaults);\n  }\n\n  /**\n   * Transform an XLR type to a TypeScript type string\n   * This is the core recursive transformation that adds TaggedTemplateValue support\n   */\n  private transformType(node: NodeType, forParameter = false): string {\n    // Primitive types get TaggedTemplateValue support\n    if (isStringType(node)) {\n      if (isPrimitiveConst(node)) {\n        return `\"${node.const}\"`;\n      }\n      return forParameter ? \"string | TaggedTemplateValue<string>\" : \"string\";\n    }\n\n    if (isNumberType(node)) {\n      if (isPrimitiveConst(node)) {\n        return `${node.const}`;\n      }\n      return forParameter ? \"number | TaggedTemplateValue<number>\" : \"number\";\n    }\n\n    if (isBooleanType(node)) {\n      if (isPrimitiveConst(node)) {\n        return `${node.const}`;\n      }\n      return forParameter\n        ? \"boolean | TaggedTemplateValue<boolean>\"\n        : \"boolean\";\n    }\n\n    // Reference types\n    if (isRefType(node)) {\n      return this.transformRefType(node, forParameter);\n    }\n\n    // Array types\n    if (isArrayType(node)) {\n      const elementType = this.transformType(node.elementType, forParameter);\n      return `Array<${elementType}>`;\n    }\n\n    // Union types\n    if (isOrType(node)) {\n      const variants = node.or.map((v) => this.transformType(v, forParameter));\n      return variants.join(\" | \");\n    }\n\n    // Intersection types\n    if (isAndType(node)) {\n      const parts = node.and.map((p) => this.transformType(p, forParameter));\n      return parts.join(\" & \");\n    }\n\n    // Record types - key type should NOT have TaggedTemplateValue since\n    // TypeScript Record keys can only be string | number | symbol\n    if (isRecordType(node)) {\n      const keyType = this.transformType(node.keyType, false);\n      const valueType = this.transformType(node.valueType, forParameter);\n      return `Record<${keyType}, ${valueType}>`;\n    }\n\n    // Object types - transform properties recursively\n    if (isObjectType(node)) {\n      if (isNamedType(node)) {\n        // Named type - reference it or its builder\n        if (isComplexObjectType(node)) {\n          return `${node.name} | FluentBuilder<${node.name}, BaseBuildContext>`;\n        }\n        return node.name;\n      }\n\n      // Anonymous object - generate inline type with transformed properties\n      return this.generateInlineObjectType(node, forParameter);\n    }\n\n    // Handle other primitive types\n    if (node.type === \"null\") return \"null\";\n    if (node.type === \"undefined\") return \"undefined\";\n    if (node.type === \"any\") return \"any\";\n    if (node.type === \"unknown\") return \"unknown\";\n    if (node.type === \"never\") return \"never\";\n    if (node.type === \"void\") return \"void\";\n\n    // Default fallback\n    return \"unknown\";\n  }\n\n  private transformRefType(node: RefType, forParameter: boolean): string {\n    const ref = node.ref;\n\n    // AssetWrapper - transform to accept Asset or FluentBuilder\n    if (ref.startsWith(\"AssetWrapper\")) {\n      this.needsAssetImport = true;\n      return \"Asset | FluentBuilder<Asset, BaseBuildContext>\";\n    }\n\n    // Expression - allow TaggedTemplateValue\n    if (ref === \"Expression\") {\n      return forParameter ? \"string | TaggedTemplateValue<string>\" : \"string\";\n    }\n\n    // Binding - allow TaggedTemplateValue\n    if (ref === \"Binding\") {\n      return forParameter ? \"string | TaggedTemplateValue<string>\" : \"string\";\n    }\n\n    // Asset reference\n    if (ref === \"Asset\" || ref.startsWith(\"Asset<\")) {\n      this.needsAssetImport = true;\n      return \"Asset\";\n    }\n\n    // Other references - check if we have a builder for them\n    const baseName = extractBaseName(ref);\n    if (this.nestedBuilders.has(baseName)) {\n      return `${baseName} | FluentBuilder<${baseName}, BaseBuildContext>`;\n    }\n\n    // Handle generic arguments\n    if (node.genericArguments && node.genericArguments.length > 0) {\n      const args = node.genericArguments.map((a) =>\n        this.transformType(a, forParameter),\n      );\n      return `${baseName}<${args.join(\", \")}>`;\n    }\n\n    return baseName;\n  }\n\n  private generateInlineObjectType(\n    node: ObjectType,\n    forParameter: boolean,\n  ): string {\n    const props = Object.entries(node.properties)\n      .map(([propName, prop]) => {\n        const propType = this.transformType(prop.node, forParameter);\n        const optional = prop.required ? \"\" : \"?\";\n        return `${propName}${optional}: ${propType}`;\n      })\n      .join(\"; \");\n\n    return `{ ${props} }`;\n  }\n}\n\n/**\n * Generate fluent builder code from a NamedType<ObjectType>\n * @param namedType - The XLR NamedType to generate a builder for\n * @param config - Optional generator configuration\n * @returns Generated TypeScript code for the fluent builder\n */\nexport function generateFluentBuilder(\n  namedType: NamedType<ObjectType>,\n  config: GeneratorConfig = {},\n): string {\n  const generator = new FluentBuilderGenerator(namedType, config);\n  return generator.generate();\n}\n","import type {\n  NodeType,\n  ObjectType,\n  ArrayType,\n  StringType,\n  NumberType,\n  BooleanType,\n} from \"@player-tools/xlr\";\n\nimport {\n  isStringType,\n  isNumberType,\n  isBooleanType,\n  isObjectType,\n  isArrayType,\n  isRefType,\n  isOrType,\n  isAndType,\n  isRecordType,\n  isNamedType,\n} from \"@player-tools/xlr-utils\";\n\n// Re-export type guards from xlr-utils for consumers\nexport {\n  isStringType,\n  isNumberType,\n  isBooleanType,\n  isObjectType,\n  isArrayType,\n  isRefType,\n  isOrType,\n  isAndType,\n  isRecordType,\n  isNamedType,\n};\n\n/**\n * Check if a primitive type has a const value (literal type)\n */\nexport function isPrimitiveConst(\n  node: NodeType,\n): node is (StringType | NumberType | BooleanType) & { const: unknown } {\n  return (\n    (isStringType(node) || isNumberType(node) || isBooleanType(node)) &&\n    \"const\" in node &&\n    node.const !== undefined\n  );\n}\n\n/**\n * Check if a ref type is an AssetWrapper\n */\nexport function isAssetWrapperRef(node: NodeType): boolean {\n  return isRefType(node) && node.ref.startsWith(\"AssetWrapper\");\n}\n\n/**\n * Check if a ref type is an Expression\n */\nexport function isExpressionRef(node: NodeType): boolean {\n  return isRefType(node) && node.ref === \"Expression\";\n}\n\n/**\n * Check if a ref type is a Binding\n */\nexport function isBindingRef(node: NodeType): boolean {\n  return isRefType(node) && node.ref === \"Binding\";\n}\n\n/**\n * Convert a property name to PascalCase for method names.\n * Handles camelCase, kebab-case, and snake_case inputs.\n *\n * @example\n * toPascalCase(\"myProperty\")  // \"MyProperty\"\n * toPascalCase(\"my-property\") // \"MyProperty\"\n * toPascalCase(\"my_property\") // \"MyProperty\"\n */\nexport function toPascalCase(str: string): string {\n  return str\n    .split(/[-_]/)\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))\n    .join(\"\");\n}\n\n/**\n * Convert a type name to a factory function name (camelCase)\n */\nexport function toFactoryName(typeName: string): string {\n  // Remove \"Asset\" suffix if present\n  const name = typeName.replace(/Asset$/, \"\");\n  return name.charAt(0).toLowerCase() + name.slice(1);\n}\n\n/**\n * Convert a type name to a builder class name\n */\nexport function toBuilderClassName(typeName: string): string {\n  return `${typeName}Builder`;\n}\n\n/**\n * Check if an object type is complex enough to warrant its own builder class\n */\nexport function isComplexObjectType(obj: ObjectType): boolean {\n  const props = Object.values(obj.properties);\n\n  // Has AssetWrapper properties\n  const hasSlots = props.some((p) => isAssetWrapperRef(p.node));\n  if (hasSlots) return true;\n\n  // Has many properties\n  if (props.length > 3) return true;\n\n  // Has nested objects\n  const hasNestedObjects = props.some(\n    (p) => isObjectType(p.node) && !isPrimitiveConst(p.node),\n  );\n  if (hasNestedObjects) return true;\n\n  return false;\n}\n\n/**\n * Get the asset type string from extends ref\n */\nexport function getAssetTypeFromExtends(obj: ObjectType): string | undefined {\n  if (!obj.extends) return undefined;\n\n  const ref = obj.extends;\n  if (ref.genericArguments && ref.genericArguments.length > 0) {\n    const typeArg = ref.genericArguments[0];\n    if (isStringType(typeArg) && typeArg.const) {\n      return typeArg.const;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Information about a property for code generation\n */\nexport interface PropertyInfo {\n  name: string;\n  node: NodeType;\n  required: boolean;\n  isSlot: boolean;\n  isArraySlot: boolean;\n  isArray: boolean;\n}\n\n/**\n * Extract property information from an ObjectType\n */\nexport function getPropertiesInfo(obj: ObjectType): PropertyInfo[] {\n  return Object.entries(obj.properties).map(([name, prop]) => {\n    const isSlot = isAssetWrapperRef(prop.node);\n    const isArray = isArrayType(prop.node);\n    const isArraySlot =\n      isArray && isAssetWrapperRef((prop.node as ArrayType).elementType);\n\n    return {\n      name,\n      node: prop.node,\n      required: prop.required,\n      isSlot,\n      isArraySlot,\n      isArray,\n    };\n  });\n}\n\n/**\n * Check if a type contains an array type (directly or within a union/intersection)\n * This handles cases like `Array<T> | T` where the property can be either\n */\nexport function containsArrayType(node: NodeType): boolean {\n  if (isArrayType(node)) {\n    return true;\n  }\n\n  if (isOrType(node)) {\n    return node.or.some(containsArrayType);\n  }\n\n  if (isAndType(node)) {\n    return node.and.some(containsArrayType);\n  }\n\n  return false;\n}\n\n/**\n * Extract generic usage string from generic params declaration\n * Converts \"T extends Foo, U = Bar\" to \"<T, U>\"\n */\nexport function extractGenericUsage(genericParams: string | undefined): string {\n  if (!genericParams) {\n    return \"\";\n  }\n\n  const params = genericParams\n    .split(\",\")\n    .map((p) => p.trim().split(\" \")[0])\n    .join(\", \");\n\n  return `<${params}>`;\n}\n"],"mappings":"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","names":["import_xlr_utils"]}