@typespec/emitter-framework 0.15.0-dev.3 → 0.15.0

package/dist/src/python/components/type-expression/type-expression.js

@@ -0,0 +1,348 @@
+import { createComponent as _$createComponent, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { Experimental_OverridableComponent } from "#core/components/index.js";
+import { useTsp } from "#core/context/index.js";
+import { reportPythonDiagnostic } from "#python/lib.js";
+import { code, For, List, mapJoin } from "@alloy-js/core";
+import * as py from "@alloy-js/python";
+import { isNeverType } from "@typespec/compiler";
+import { datetimeModule, decimalModule, typingModule } from "../../builtins.js";
+import { efRefkey } from "../../utils/refkey.js";
+import { ArrayExpression } from "../array-expression/array-expression.js";
+import { RecordExpression } from "../record-expression/record-expression.js";
+export function TypeExpression(props) {
+  const {
+    $
+  } = useTsp();
+  const type = props.type;
+  if (!props.noReference && isDeclaration($, type)) {
+    return _$createComponent(Experimental_OverridableComponent, {
+      reference: true,
+      type: type,
+      get children() {
+        return _$createComponent(py.Reference, {
+          get refkey() {
+            return efRefkey(type);
+          }
+        });
+      }
+    });
+  }
+  switch (type.kind) {
+    case "Scalar": // Custom types based on primitives (Intrinsics)
+    case "Intrinsic":
+      // Language primitives like `string`, `number`, etc.
+      if (isNeverType(type)) {
+        return typingModule["."]["Never"];
+      }
+      return [_$memo(() => getScalarIntrinsicExpression($, type))];
+    case "Boolean":
+    case "Number":
+    case "String":
+      // Single literal values are wrapped in Literal[...]
+      return [_$memo(() => typingModule["."]["Literal"]), "[", _$memo(() => formatLiteralValue(type)), "]"];
+    case "Tuple":
+      return ["tuple[", _$createComponent(For, {
+        get each() {
+          return type.values;
+        },
+        comma: true,
+        space: true,
+        children: element => _$createComponent(TypeExpression, {
+          type: element
+        })
+      }), "]"];
+    case "Union":
+      {
+        const variants = Array.from(type.variants?.values?.() ?? []);
+
+        // Check if all variants are literals or named union variant refs with literal values
+        const isLiteralOrVariantRef = t => {
+          if (!t) return false;
+          if (isLiteral($, t)) return true;
+          // Named union variant with a literal inner value
+          if (t.kind === "UnionVariant" && t.union?.name) {
+            return isLiteral($, t.type);
+          }
+          return false;
+        };
+        const innerTypes = variants.map(v => v.type);
+        if (innerTypes.every(isLiteralOrVariantRef)) {
+          // All literals - render as Literal[...]
+          const literalValues = variants.map(v => {
+            const innerType = v.type;
+            // Named union variant ref with literal value
+            if (innerType.kind === "UnionVariant" && innerType.union?.name) {
+              const variantName = String(innerType.name).toUpperCase();
+              return code`${efRefkey(innerType.union)}.${variantName}`;
+            }
+            if (isLiteral($, innerType)) {
+              return formatLiteralValue(innerType);
+            }
+            return undefined;
+          }).filter(Boolean);
+          return [_$memo(() => typingModule["."]["Literal"]), "[", _$createComponent(List, {
+            children: literalValues,
+            joiner: ", "
+          }), "]"];
+        }
+
+        // Not all literals - render as union type
+        return mapJoin(() => variants, v => _$createComponent(TypeExpression, {
+          get type() {
+            return v.type;
+          }
+        }), {
+          joiner: " | "
+        });
+      }
+    case "UnionVariant":
+      {
+        // Union variant from a named union with a literal value
+        if (type.union && type.union.name && isLiteral($, type.type)) {
+          // Use the variant's name (e.g., "red", "active"), converted to UPPER_CASE by the enum
+          const variantName = String(type.name).toUpperCase();
+          return [_$memo(() => typingModule["."]["Literal"]), "[", _$memo(() => efRefkey(type.union)), ".", variantName, "]"];
+        }
+        // Unnamed union variant or non-literal value, unwrap to its inner type
+        return _$createComponent(TypeExpression, {
+          get type() {
+            return type.type;
+          }
+        });
+      }
+    case "ModelProperty":
+      return _$createComponent(TypeExpression, {
+        get type() {
+          return type.type;
+        }
+      });
+    case "Model":
+      if ($.array.is(type)) {
+        const elementType = type.indexer.value;
+        return _$createComponent(ArrayExpression, {
+          elementType: elementType
+        });
+      }
+      if ($.record.is(type)) {
+        const elementType = type.indexer.value;
+        return _$createComponent(RecordExpression, {
+          elementType: elementType
+        });
+      }
+
+      // TODO: When TypeSpec adds true generics support, handle generic type references here.
+      // Currently, TypeSpec templates are macros that expand to concrete types, so template
+      // instances (e.g., Response<string>) are treated as regular concrete types, not as
+      // parameterized generic types (e.g., Response[str]).
+      // When generics are implemented, this is where we would render: ClassName[TypeArg, ...]
+
+      // Regular named models should be handled as references
+      if (type.name) {
+        return _$createComponent(Experimental_OverridableComponent, {
+          reference: true,
+          type: type,
+          get children() {
+            return _$createComponent(py.Reference, {
+              get refkey() {
+                return efRefkey(type);
+              }
+            });
+          }
+        });
+      }
+      reportPythonDiagnostic($.program, {
+        code: "python-unsupported-type",
+        target: type
+      });
+      return [];
+    case "TemplateParameter":
+      return code`${String(type.node.id.sv)}`;
+    case "Operation":
+      {
+        // Render function types as typing.Callable[[ArgTypes...], ReturnType]
+        // If parameters cannot be enumerated, fall back to Callable[..., ReturnType]
+        let paramTypes = null;
+        const op = type;
+        if (op.parameters) {
+          try {
+            const {
+              $
+            } = useTsp();
+            const modelProps = $.model.getProperties(op.parameters);
+            paramTypes = Array.from(modelProps.values()).map(p => p.type);
+          } catch {
+            // Unknown/unsupported params shape
+            paramTypes = null;
+          }
+        } else {
+          paramTypes = [];
+        }
+        return [_$memo(() => typingModule["."]["Callable"]), "[", _$memo(() => paramTypes === null ? ["..."] : paramTypes.length > 0 ? ["[", _$createComponent(For, {
+          each: paramTypes,
+          comma: true,
+          space: true,
+          children: t => _$createComponent(TypeExpression, {
+            type: t
+          })
+        }), "]"] : ["[]"]), ", ", _$createComponent(TypeExpression, {
+          get type() {
+            return type.returnType;
+          }
+        }), "]"];
+      }
+    default:
+      reportPythonDiagnostic($.program, {
+        code: "python-unsupported-type",
+        target: type
+      });
+      // Return empty fragment - the diagnostic has already been reported
+      return [];
+  }
+}
+
+/**
+ * Checks if a type is a literal (string, numeric, or boolean).
+ */
+function isLiteral($, type) {
+  return $.literal.isString(type) || $.literal.isNumeric(type) || $.literal.isBoolean(type);
+}
+
+/**
+ * Formats a literal type value for use in Python's Literal[...] syntax.
+ */
+function formatLiteralValue(type) {
+  switch (type.kind) {
+    case "String":
+      return JSON.stringify(type.value);
+    case "Boolean":
+      return type.value ? "True" : "False";
+    case "Number":
+      return String(type.value);
+    default:
+      return String(type.value);
+  }
+}
+const intrinsicNameToPythonType = new Map([
+// Core types
+["unknown", "Any"],
+// Matches Python's `Any`
+["string", "str"],
+// Matches Python's `str`
+["boolean", "bool"],
+// Matches Python's `bool`
+["null", "None"],
+// Matches Python's `None`
+["void", "None"],
+// Matches Python's `None`
+["never", "Never"],
+// Matches Python's `Never`
+["bytes", "bytes"],
+// Matches Python's `bytes`
+
+// Numeric types
+["numeric", "number"],
+// Parent type for all numeric types
+["integer", "int"],
+// Broad integer category, maps to `int`
+["float", "float"],
+// Broad float category, maps to `float`
+["decimal", "Decimal"],
+// Broad decimal category, maps to `Decimal`
+["decimal128", "Decimal"],
+// 128-bit decimal category, maps to `Decimal`
+["int64", "int"],
+// Use `int` to handle large 64-bit integers
+["int32", "int"],
+// 32-bit integer fits in Python's `int`
+["int16", "int"],
+// 16-bit integer
+["int8", "int"],
+// 8-bit integer
+["safeint", "int"],
+// Safe integer fits within Python limits
+["uint64", "int"],
+// Use `int` for unsigned 64-bit integers
+["uint32", "int"],
+// 32-bit unsigned integer
+["uint16", "int"],
+// 16-bit unsigned integer
+["uint8", "int"],
+// 8-bit unsigned integer
+["float32", "float"],
+// Maps to Python's `float`
+["float64", "float"],
+// Maps to Python's `float`.
+
+// Date and time types
+["plainDate", "str"],
+// Use `str` for plain calendar dates
+["plainTime", "str"],
+// Use `str` for plain clock times
+["utcDateTime", "datetime"],
+// Use `datetime` for UTC date-times
+["offsetDateTime", "str"],
+// Use `str` for timezone-specific date-times
+["duration", "str"],
+// Duration as an ISO 8601 string or custom format
+
+// String types
+["url", "str"] // Matches Python's `str`
+]);
+const pythonTypeToImport = new Map([["Any", typingModule["."]["Any"]], ["Never", typingModule["."]["Never"]], ["datetime", datetimeModule["."]["datetime"]], ["Decimal", decimalModule["."]["Decimal"]]]);
+function getScalarIntrinsicExpression($, type) {
+  let intrinsicName;
+  if ($.scalar.is(type)) {
+    if ($.scalar.isUtcDateTime(type) || $.scalar.extendsUtcDateTime(type)) {
+      const encoding = $.scalar.getEncoding(type);
+      intrinsicName = "utcDateTime";
+      switch (encoding?.encoding) {
+        case "unixTimestamp":
+        case "rfc7231":
+        case "rfc3339":
+        default:
+          intrinsicName = `utcDateTime`;
+          break;
+      }
+    }
+    intrinsicName = $.scalar.getStdBase(type)?.name ?? "";
+  } else {
+    intrinsicName = type.name;
+  }
+  let pythonType = intrinsicNameToPythonType.get(intrinsicName);
+  const importModule = pythonTypeToImport.get(pythonType ?? "");
+  pythonType = importModule ? importModule : pythonType;
+  if (!pythonType) {
+    reportPythonDiagnostic($.program, {
+      code: "python-unsupported-scalar",
+      target: type
+    });
+    return "any";
+  }
+  return pythonType;
+}
+
+// TODO: When TypeSpec adds true generics support, add helper to detect generic type instances.
+// Currently, TypeSpec templates expand to concrete types at compile time, so we treat all
+// template instances as regular concrete types.
+
+function isDeclaration($, type) {
+  switch (type.kind) {
+    case "Namespace":
+    case "Interface":
+    case "Enum":
+    case "Operation":
+    case "EnumMember":
+    case "UnionVariant":
+      return false;
+    case "Model":
+      if ($.array.is(type) || $.record.is(type)) {
+        return false;
+      }
+      return Boolean(type.name);
+    case "Union":
+      return Boolean(type.name);
+    default:
+      return false;
+  }
+}
+//# sourceMappingURL=type-expression.js.map

package/dist/src/python/components/type-expression/type-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Experimental_OverridableComponent","useTsp","reportPythonDiagnostic","code","For","List","mapJoin","py","isNeverType","datetimeModule","decimalModule","typingModule","efRefkey","ArrayExpression","RecordExpression","TypeExpression","props","$","type","noReference","isDeclaration","_$createComponent","reference","children","Reference","refkey","kind","_$memo","getScalarIntrinsicExpression","formatLiteralValue","each","values","comma","space","element","variants","Array","from","isLiteralOrVariantRef","t","isLiteral","union","name","innerTypes","map","v","every","literalValues","innerType","variantName","String","toUpperCase","undefined","filter","Boolean","joiner","array","is","elementType","indexer","value","record","program","target","node","id","sv","paramTypes","op","parameters","modelProps","model","getProperties","p","length","returnType","literal","isString","isNumeric","isBoolean","JSON","stringify","intrinsicNameToPythonType","Map","pythonTypeToImport","intrinsicName","scalar","isUtcDateTime","extendsUtcDateTime","encoding","getEncoding","getStdBase","pythonType","get","importModule"],"sources":["../../../../../src/python/components/type-expression/type-expression.tsx"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/src/python/components/type-expression/type-expression.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-expression.test.d.ts.map

package/dist/src/python/components/type-expression/type-expression.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-expression.test.d.ts","sourceRoot":"","sources":["../../../../../src/python/components/type-expression/type-expression.test.tsx"],"names":[],"mappings":""}