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

package/dist/index.legacy-esm.js

@@ -0,0 +1,472 @@
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/generators/fluent/src/generator.ts
+import { isGenericNamedType } from "@player-tools/xlr-utils";
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/generators/fluent/src/utils.ts
+import {
+  isStringType,
+  isNumberType,
+  isBooleanType,
+  isObjectType,
+  isArrayType,
+  isRefType,
+  isOrType,
+  isAndType,
+  isRecordType,
+  isNamedType
+} from "@player-tools/xlr-utils";
+function isPrimitiveConst(node) {
+  return (isStringType(node) || isNumberType(node) || isBooleanType(node)) && "const" in node && node.const !== void 0;
+}
+function isAssetWrapperRef(node) {
+  return isRefType(node) && node.ref.startsWith("AssetWrapper");
+}
+function isExpressionRef(node) {
+  return isRefType(node) && node.ref === "Expression";
+}
+function isBindingRef(node) {
+  return 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) => 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 (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 = 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 (isArrayType(node)) {
+    return true;
+  }
+  if (isOrType(node)) {
+    return node.or.some(containsArrayType);
+  }
+  if (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 (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 (isObjectType(node)) {
+      if (isNamedType(node) && isComplexObjectType(node)) {
+        this.nestedBuilders.set(node.name, node);
+        this.collectNestedTypes(node);
+      } else if (!isNamedType(node) && isComplexObjectType(node)) {
+        const name = toPascalCase(parentName);
+        this.nestedBuilders.set(name, node);
+        this.collectNestedTypes(node);
+      } else if (isNamedType(node)) {
+        this.referencedTypes.add(node.name);
+      }
+    } else if (isArrayType(node)) {
+      this.collectNestedTypesFromNode(node.elementType, parentName);
+    } else if (isOrType(node)) {
+      for (const variant of node.or) {
+        this.collectNestedTypesFromNode(variant, parentName);
+      }
+    } else if (isAndType(node)) {
+      for (const part of node.and) {
+        this.collectNestedTypesFromNode(part, parentName);
+      }
+    } else if (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 (isStringType(node)) {
+      if (isPrimitiveConst(node)) {
+        return `"${node.const}"`;
+      }
+      return forParameter ? "string | TaggedTemplateValue<string>" : "string";
+    }
+    if (isNumberType(node)) {
+      if (isPrimitiveConst(node)) {
+        return `${node.const}`;
+      }
+      return forParameter ? "number | TaggedTemplateValue<number>" : "number";
+    }
+    if (isBooleanType(node)) {
+      if (isPrimitiveConst(node)) {
+        return `${node.const}`;
+      }
+      return forParameter ? "boolean | TaggedTemplateValue<boolean>" : "boolean";
+    }
+    if (isRefType(node)) {
+      return this.transformRefType(node, forParameter);
+    }
+    if (isArrayType(node)) {
+      const elementType = this.transformType(node.elementType, forParameter);
+      return `Array<${elementType}>`;
+    }
+    if (isOrType(node)) {
+      const variants = node.or.map((v) => this.transformType(v, forParameter));
+      return variants.join(" | ");
+    }
+    if (isAndType(node)) {
+      const parts = node.and.map((p) => this.transformType(p, forParameter));
+      return parts.join(" & ");
+    }
+    if (isRecordType(node)) {
+      const keyType = this.transformType(node.keyType, false);
+      const valueType = this.transformType(node.valueType, forParameter);
+      return `Record<${keyType}, ${valueType}>`;
+    }
+    if (isObjectType(node)) {
+      if (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();
+}
+export {
+  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.mjs.map