@alloy-js/python 0.0.1

package/dist/src/components/Declaration.d.ts

@@ -0,0 +1,48 @@
+import { Children, OutputSymbolFlags, Refkey } from "@alloy-js/core";
+import { PythonElements } from "../name-policy.js";
+import { PythonOutputSymbol } from "../symbols/index.js";
+export interface BaseDeclarationProps {
+    /**
+     * The base name of this declaration. May change depending on naming policy
+     * and any conflicts.
+     */
+    name: string;
+    /**
+     * The refkey or array of refkeys for this declaration.
+     */
+    refkey?: Refkey | Refkey[];
+    /**
+     * Flags for the symbol created by this component.
+     */
+    flags?: OutputSymbolFlags;
+    children?: Children;
+    /**
+     * Documentation for this declaration
+     */
+    doc?: Children;
+}
+export interface DeclarationProps extends Omit<BaseDeclarationProps, "name"> {
+    /**
+     * The name of this declaration.
+     */
+    name?: string;
+    /**
+     * The name policy kind to apply to the declaration.
+     */
+    nameKind?: PythonElements;
+    /**
+     * The symbol to use for this declaration.
+     */
+    symbol?: PythonOutputSymbol;
+}
+/**
+ * A Python declaration, which can be a class, function, variable, etc.
+ *
+ * @remarks
+ * This component is used to create a declaration with a symbol that can be
+ * referenced in the code. It can also be used to create a member scope for
+ * member containers.
+ *
+ */
+export declare function Declaration(props: DeclarationProps): Children;
+//# sourceMappingURL=Declaration.d.ts.map

package/dist/src/components/Declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Declaration.d.ts","sourceRoot":"","sources":["../../../src/components/Declaration.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,iBAAiB,EACjB,MAAM,EACP,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE3B;;OAEG;IACH,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAE1B,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB;;OAEG;IACH,GAAG,CAAC,EAAE,QAAQ,CAAC;CAChB;AAED,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAC;IAC1E;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;IAE1B;;OAEG;IACH,MAAM,CAAC,EAAE,kBAAkB,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,YA4BlD"}

package/dist/src/components/Declaration.js

@@ -0,0 +1,37 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Declaration as CoreDeclaration, MemberScope, OutputSymbolFlags } from "@alloy-js/core";
+import { createPythonSymbol } from "../symbol-creation.js";
+/**
+ * A Python declaration, which can be a class, function, variable, etc.
+ *
+ * @remarks
+ * This component is used to create a declaration with a symbol that can be
+ * referenced in the code. It can also be used to create a member scope for
+ * member containers.
+ *
+ */
+export function Declaration(props) {
+  let sym;
+  if (props.symbol) {
+    sym = props.symbol;
+  } else {
+    sym = createPythonSymbol(props.name, {
+      refkeys: props.refkey,
+      flags: props.flags
+    }, props.nameKind, true);
+  }
+  function withMemberScope(children) {
+    return _$createComponent(MemberScope, {
+      owner: sym,
+      children: children
+    });
+  }
+  let children = () => props.children;
+  if (sym.flags & OutputSymbolFlags.MemberContainer) {
+    children = withMemberScope(children);
+  }
+  return _$createComponent(CoreDeclaration, {
+    symbol: sym,
+    children: children
+  });
+}

package/dist/src/components/EnumDeclaration.d.ts

@@ -0,0 +1,164 @@
+import { Children } from "@alloy-js/core";
+import { BaseDeclarationProps } from "./Declaration.js";
+export interface EnumProps extends BaseDeclarationProps {
+    /**
+     * The base type of the enum. One of: 'Enum', 'IntEnum', 'StrEnum', 'Flag', 'IntFlag'.
+     * Defaults to 'Enum'.
+     */
+    baseType?: "Enum" | "IntEnum" | "StrEnum" | "Flag" | "IntFlag";
+    /**
+     * Members of the enum as an array of objects.
+     */
+    members?: Array<{
+        name: string;
+        value?: Children;
+        jsValue?: string | number;
+        doc?: string;
+    }>;
+    /**
+     * The enum style: 'classic' (default), 'auto', or 'functional'.
+     */
+    style?: "classic" | "auto" | "functional";
+    /**
+     * Optional docstring for the enum.
+     */
+    doc?: Children;
+}
+/**
+ * A Python enum declaration, following https://docs.python.org/3.11/library/enum.html.
+ *
+ * @example
+ * ```tsx
+ * <EnumDeclaration name="Direction" style="functional">
+ *   members={[
+ *     { name: "NORTH" },
+ *     { name: "SOUTH" },
+ *     { name: "EAST" },
+ *     { name: "WEST" },
+ *   ]}
+ * />
+ * ```
+ * This will generate:
+ * ```python
+ * from enum import Enum
+ * class Direction(Enum):
+ *     NORTH = "NORTH"
+ *     SOUTH = "SOUTH"
+ *     EAST = "EAST"
+ *     WEST = "WEST"
+ * ```
+ */
+export declare function EnumDeclaration(props: EnumProps): Children;
+/**
+ * Create a Python enum using the functional syntax.
+ *
+ * This generates enums using the `Enum('Name', [...])` or `Enum('Name', {...})` syntax.
+ * The format depends on whether enum members have explicit values:
+ * - Members without values: `Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])`
+ * - Members with values: `Enum('Direction', {'NORTH': 1, 'SOUTH': 2, 'EAST': 3, 'WEST': 4})`
+ *
+ * @example
+ * ```tsx
+ * <FunctionalEnumDeclaration
+ *   name="Direction"
+ *   members={[
+ *     { name: "NORTH" },
+ *     { name: "SOUTH" },
+ *     { name: "EAST" },
+ *     { name: "WEST" }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * Direction = Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])
+ * ```
+ *
+ * @example
+ * ```tsx
+ * <FunctionalEnumDeclaration
+ *   name="Status"
+ *   members={[
+ *     { name: "PENDING", value: 1 },
+ *     { name: "ACTIVE", value: 2 },
+ *     { name: "INACTIVE", value: 3 }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * Status = Enum('Status', {'PENDING': 1, 'ACTIVE': 2, 'INACTIVE': 3})
+ * ```
+ */
+export declare function FunctionalEnumDeclaration(props: EnumProps): Children;
+/**
+ * Create a Python enum using the class-based syntax.
+ *
+ * This generates enums using the `class Name(Enum):` syntax with member definitions
+ * inside the class body. Supports various member value styles including auto-generated
+ * values, explicit values, and custom base types.
+ *
+ * @example
+ * ```tsx
+ * <ClassEnumDeclaration
+ *   name="Direction"
+ *   members={[
+ *     { name: "NORTH" },
+ *     { name: "SOUTH" },
+ *     { name: "EAST" },
+ *     { name: "WEST" }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * class Direction(Enum):
+ *     NORTH = "NORTH"
+ *     SOUTH = "SOUTH"
+ *     EAST = "EAST"
+ *     WEST = "WEST"
+ * ```
+ *
+ * @example
+ * With explicit values:
+ * ```tsx
+ * <ClassEnumDeclaration
+ *   name="Status"
+ *   members={[
+ *     { name: "PENDING", value: 1 },
+ *     { name: "ACTIVE", value: 2 },
+ *     { name: "INACTIVE", value: 3 }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * class Status(Enum):
+ *     PENDING = 1
+ *     ACTIVE = 2
+ *     INACTIVE = 3
+ * ```
+ *
+ * @example
+ * With auto() values:
+ * ```tsx
+ * <ClassEnumDeclaration
+ *   name="Color"
+ *   style="auto"
+ *   members={[
+ *     { name: "RED" },
+ *     { name: "GREEN" },
+ *     { name: "BLUE" }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * class Color(Enum):
+ *     RED = auto()
+ *     GREEN = auto()
+ *     BLUE = auto()
+ * ```
+ */
+export declare function ClassEnumDeclaration(props: EnumProps): Children;
+//# sourceMappingURL=EnumDeclaration.d.ts.map

package/dist/src/components/EnumDeclaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnumDeclaration.d.ts","sourceRoot":"","sources":["../../../src/components/EnumDeclaration.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAKxD,MAAM,WAAW,SAAU,SAAQ,oBAAoB;IACrD;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;IAC/D;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,QAAQ,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;IACH;;OAEG;IACH,KAAK,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,YAAY,CAAC;IAC1C;;OAEG;IACH,GAAG,CAAC,EAAE,QAAQ,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,YAM/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,YA+CzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,YAwDpD"}

package/dist/src/components/EnumDeclaration.js

@@ -0,0 +1,278 @@
+import { createComponent as _$createComponent, memo as _$memo, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { Declaration as CoreDeclaration, For, MemberScope, OutputSymbolFlags, Scope, Show, useBinder } from "@alloy-js/core";
+import { enumModule } from "../builtins/python.js";
+import { createPythonSymbol } from "../symbol-creation.js";
+import { usePythonScope } from "../symbols/scopes.js";
+import { EnumMember } from "./EnumMember.js";
+import { PythonBlock } from "./PythonBlock.js";
+import { SimpleCommentBlock } from "./index.js";
+/**
+ * A Python enum declaration, following https://docs.python.org/3.11/library/enum.html.
+ *
+ * @example
+ * ```tsx
+ * <EnumDeclaration name="Direction" style="functional">
+ *   members={[
+ *     { name: "NORTH" },
+ *     { name: "SOUTH" },
+ *     { name: "EAST" },
+ *     { name: "WEST" },
+ *   ]}
+ * />
+ * ```
+ * This will generate:
+ * ```python
+ * from enum import Enum
+ * class Direction(Enum):
+ *     NORTH = "NORTH"
+ *     SOUTH = "SOUTH"
+ *     EAST = "EAST"
+ *     WEST = "WEST"
+ * ```
+ */
+export function EnumDeclaration(props) {
+  // Handle enum styles
+  if (props.style === "functional") {
+    return _$createComponent(FunctionalEnumDeclaration, props);
+  }
+  return _$createComponent(ClassEnumDeclaration, props);
+}
+
+/**
+ * Create a Python enum using the functional syntax.
+ *
+ * This generates enums using the `Enum('Name', [...])` or `Enum('Name', {...})` syntax.
+ * The format depends on whether enum members have explicit values:
+ * - Members without values: `Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])`
+ * - Members with values: `Enum('Direction', {'NORTH': 1, 'SOUTH': 2, 'EAST': 3, 'WEST': 4})`
+ *
+ * @example
+ * ```tsx
+ * <FunctionalEnumDeclaration
+ *   name="Direction"
+ *   members={[
+ *     { name: "NORTH" },
+ *     { name: "SOUTH" },
+ *     { name: "EAST" },
+ *     { name: "WEST" }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * Direction = Enum('Direction', ['NORTH', 'SOUTH', 'EAST', 'WEST'])
+ * ```
+ *
+ * @example
+ * ```tsx
+ * <FunctionalEnumDeclaration
+ *   name="Status"
+ *   members={[
+ *     { name: "PENDING", value: 1 },
+ *     { name: "ACTIVE", value: 2 },
+ *     { name: "INACTIVE", value: 3 }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * Status = Enum('Status', {'PENDING': 1, 'ACTIVE': 2, 'INACTIVE': 3})
+ * ```
+ */
+export function FunctionalEnumDeclaration(props) {
+  const binder = useBinder();
+  const scope = usePythonScope();
+  const sym = createPythonSymbol(props.name, {
+    binder: binder,
+    scope: scope,
+    refkeys: props.refkey,
+    flags: OutputSymbolFlags.StaticMemberContainer
+  }, "enum", false);
+  const members = props.members ?? [];
+  let opener, ender;
+  if (members.length && members.every(m => m.value === undefined)) {
+    // List of names: Enum('Direction', ['NORTH', ...])
+    opener = "[";
+    ender = "]";
+  } else {
+    // List of name-value pairs: Enum('Direction', {'NORTH': 1, ...})
+    opener = "{";
+    ender = "}";
+  }
+  const memberExpr = [opener, _$createComponent(For, {
+    each: members,
+    joiner: ", ",
+    children: m => _$createComponent(EnumMember, {
+      get name() {
+        return m.name;
+      },
+      get value() {
+        return m.value;
+      },
+      functional: true
+    })
+  }), ender];
+  return [_$createComponent(CoreDeclaration, {
+    symbol: sym,
+    get children() {
+      return [_$memo(() => sym.name), " = ", _$memo(() => enumModule["."].Enum), "('", _$memo(() => sym.name), "',", " ", _$createComponent(MemberScope, {
+        owner: sym,
+        get children() {
+          return _$createComponent(Scope, {
+            get name() {
+              return props.name;
+            },
+            kind: "enum",
+            children: memberExpr
+          });
+        }
+      }), ")"];
+    }
+  })];
+}
+
+/**
+ * Create a Python enum using the class-based syntax.
+ *
+ * This generates enums using the `class Name(Enum):` syntax with member definitions
+ * inside the class body. Supports various member value styles including auto-generated
+ * values, explicit values, and custom base types.
+ *
+ * @example
+ * ```tsx
+ * <ClassEnumDeclaration
+ *   name="Direction"
+ *   members={[
+ *     { name: "NORTH" },
+ *     { name: "SOUTH" },
+ *     { name: "EAST" },
+ *     { name: "WEST" }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * class Direction(Enum):
+ *     NORTH = "NORTH"
+ *     SOUTH = "SOUTH"
+ *     EAST = "EAST"
+ *     WEST = "WEST"
+ * ```
+ *
+ * @example
+ * With explicit values:
+ * ```tsx
+ * <ClassEnumDeclaration
+ *   name="Status"
+ *   members={[
+ *     { name: "PENDING", value: 1 },
+ *     { name: "ACTIVE", value: 2 },
+ *     { name: "INACTIVE", value: 3 }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * class Status(Enum):
+ *     PENDING = 1
+ *     ACTIVE = 2
+ *     INACTIVE = 3
+ * ```
+ *
+ * @example
+ * With auto() values:
+ * ```tsx
+ * <ClassEnumDeclaration
+ *   name="Color"
+ *   style="auto"
+ *   members={[
+ *     { name: "RED" },
+ *     { name: "GREEN" },
+ *     { name: "BLUE" }
+ *   ]}
+ * />
+ * ```
+ * renders to:
+ * ```python
+ * class Color(Enum):
+ *     RED = auto()
+ *     GREEN = auto()
+ *     BLUE = auto()
+ * ```
+ */
+export function ClassEnumDeclaration(props) {
+  const baseType = props.baseType || "Enum";
+  const binder = useBinder();
+  const scope = usePythonScope();
+  const sym = createPythonSymbol(props.name, {
+    binder: binder,
+    scope: scope,
+    refkeys: props.refkey,
+    flags: OutputSymbolFlags.StaticMemberContainer
+  }, "enum", false);
+  let memberList = (props.members ?? []).map(m => m.value === undefined ? {
+    ...m,
+    auto: false
+  } : m);
+  if (props.style === "auto") {
+    memberList = memberList.map(m => m.value === undefined ? {
+      name: m.name,
+      auto: true
+    } : m);
+  }
+  return _$createComponent(CoreDeclaration, {
+    symbol: sym,
+    get children() {
+      return [_$createComponent(Show, {
+        get when() {
+          return Boolean(props.doc);
+        },
+        get children() {
+          return [_$createComponent(SimpleCommentBlock, {
+            get children() {
+              return props.doc;
+            }
+          }), _$createIntrinsic("hbr", {})];
+        }
+      }), "class ", _$memo(() => sym.name), "(", _$memo(() => enumModule["."][baseType]), ")", _$createComponent(MemberScope, {
+        owner: sym,
+        get children() {
+          return _$createComponent(Scope, {
+            get name() {
+              return sym.name;
+            },
+            kind: "enum",
+            get children() {
+              return _$createComponent(PythonBlock, {
+                opener: ":",
+                get children() {
+                  return [_$createComponent(For, {
+                    each: memberList,
+                    hardline: true,
+                    children: member => _$createComponent(EnumMember, {
+                      get name() {
+                        return member.name;
+                      },
+                      get value() {
+                        return member.value;
+                      },
+                      get jsValue() {
+                        return member.jsValue;
+                      },
+                      get auto() {
+                        return member.auto;
+                      },
+                      get doc() {
+                        return member.doc;
+                      }
+                    })
+                  }), _$memo(() => props.children)];
+                }
+              });
+            }
+          });
+        }
+      })];
+    }
+  });
+}

package/dist/src/components/EnumMember.d.ts

@@ -0,0 +1,46 @@
+import { Children, Refkey } from "@alloy-js/core";
+export interface EnumMemberProps {
+    /**
+     * The name of the enum member.
+     */
+    name: string;
+    /**
+     * Refkey for the enum member symbol. If the refkey is not provided, a symbol
+     * will be created and the member cannot be referenced by refkey.
+     */
+    refkey?: Refkey;
+    /**
+     * The value of the enum member.
+     */
+    value?: Children;
+    /**
+     * The JS value of the enum member.
+     */
+    jsValue?: string | number;
+    /**
+     * Functional mappings/list
+     */
+    functional?: boolean;
+    /**
+     * Will use auto() to generate the value if set to true.
+     */
+    auto?: boolean;
+    /**
+     * Documentation for the enum member.
+     */
+    doc?: Children;
+}
+/**
+ * A Python enum member.
+ *
+ * @example
+ * ```tsx
+ * <EnumMember name="NORTH" />
+ * ```
+ * This will generate:
+ * ```python
+ * NORTH
+ * ```
+ */
+export declare function EnumMember(props: EnumMemberProps): Children;
+//# sourceMappingURL=EnumMember.d.ts.map

package/dist/src/components/EnumMember.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnumMember.d.ts","sourceRoot":"","sources":["../../../src/components/EnumMember.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAqB,MAAM,EAAQ,MAAM,gBAAgB,CAAC;AAO3E,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,KAAK,CAAC,EAAE,QAAQ,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE1B;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,GAAG,CAAC,EAAE,QAAQ,CAAC;CAChB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,YAkChD"}

package/dist/src/components/EnumMember.js

@@ -0,0 +1,67 @@
+import { createComponent as _$createComponent, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { OutputSymbolFlags, Show } from "@alloy-js/core";
+import { enumModule } from "../builtins/python.js";
+import { createPythonSymbol } from "../symbol-creation.js";
+import { Atom } from "./Atom.js";
+import { SimpleInlineComment } from "./index.js";
+/**
+ * A Python enum member.
+ *
+ * @example
+ * ```tsx
+ * <EnumMember name="NORTH" />
+ * ```
+ * This will generate:
+ * ```python
+ * NORTH
+ * ```
+ */
+export function EnumMember(props) {
+  const autoReference = props.auto === true ? enumModule["."].auto : undefined;
+  const value = props.auto === true ? [autoReference, "()"] : props.value;
+  const sym = createPythonSymbol(props.name, {
+    refkeys: props.refkey,
+    flags: OutputSymbolFlags.StaticMember
+  }, "enum-member", true);
+  const valueCode = props.jsValue !== undefined ? _$createComponent(Atom, {
+    get jsValue() {
+      return props.jsValue;
+    }
+  }) : value;
+  if (props.functional) {
+    return ["'", _$memo(() => sym.name), "'", _$createComponent(Show, {
+      when: valueCode !== undefined,
+      get children() {
+        return [" : ", valueCode];
+      }
+    }), _$createComponent(Show, {
+      get when() {
+        return props.doc !== undefined;
+      },
+      get children() {
+        return _$createComponent(SimpleInlineComment, {
+          get children() {
+            return props.doc;
+          }
+        });
+      }
+    })];
+  }
+  return [_$memo(() => sym.name), _$createComponent(Show, {
+    when: valueCode !== undefined,
+    get children() {
+      return [" = ", valueCode];
+    }
+  }), _$createComponent(Show, {
+    get when() {
+      return props.doc !== undefined;
+    },
+    get children() {
+      return _$createComponent(SimpleInlineComment, {
+        get children() {
+          return props.doc;
+        }
+      });
+    }
+  })];
+}

package/dist/src/components/FunctionCallExpression.d.ts

@@ -0,0 +1,19 @@
+import { Children } from "@alloy-js/core";
+export interface FunctionCallExpressionProps {
+    target: Children;
+    args?: Children[];
+}
+/**
+ * A Python function call expression.
+ *
+ * @example
+ * ```tsx
+ * <FunctionCallExpression target="foo" args={["arg1", "arg2"]} />
+ * ```
+ * This will generate:
+ * ```python
+ * foo(arg1, arg2)
+ * ```
+ */
+export declare function FunctionCallExpression(props: FunctionCallExpressionProps): Children;
+//# sourceMappingURL=FunctionCallExpression.d.ts.map

package/dist/src/components/FunctionCallExpression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionCallExpression.d.ts","sourceRoot":"","sources":["../../../src/components/FunctionCallExpression.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAqB,MAAM,gBAAgB,CAAC;AAE7D,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,QAAQ,CAAC;IACjB,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,2BAA2B,YAgBxE"}