@alloy-js/python 0.0.1

package/dist/src/symbols/reference.js

@@ -0,0 +1,60 @@
+import { memo, OutputSymbolFlags, resolve, untrack, useContext, useMemberScope } from "@alloy-js/core";
+import { PythonSourceFileContext } from "../components/SourceFile.js";
+export function ref(refkey) {
+  const sourceFile = useContext(PythonSourceFileContext);
+  const resolveResult = resolve(refkey);
+  const currentScope = useMemberScope();
+  return memo(() => {
+    if (resolveResult.value === undefined) {
+      return ["<Unresolved Symbol>", undefined];
+    }
+    const {
+      targetDeclaration,
+      pathDown,
+      memberPath
+    } = resolveResult.value;
+
+    // if we resolved a instance member, check if we should be able to access
+    // it.
+    if (targetDeclaration.flags & OutputSymbolFlags.InstanceMember) {
+      if (currentScope?.instanceMembers !== targetDeclaration.scope) {
+        throw new Error("Cannot resolve member symbols from a different member scope");
+      }
+    }
+
+    // Where the target declaration is relative to the referencing scope.
+    // * module: target symbol is in a different module
+    // * local: target symbol is within the current module
+    const targetLocation = pathDown[0]?.kind ?? "local";
+    let localSymbol;
+    if (targetLocation === "module") {
+      // Handling of targets in other modules, either created with createModule()
+      // or from other files.
+      const symbolPath = [...pathDown.slice(1).map(s => s.owner), targetDeclaration];
+      const importSymbol = symbolPath[0];
+      localSymbol = untrack(() => sourceFile.scope.addImport(importSymbol, pathDown[0]));
+    }
+    if (memberPath && memberPath.length > 0) {
+      if (localSymbol) {
+        memberPath[0] = localSymbol;
+      }
+      return [buildMemberExpression(memberPath), memberPath.at(-1)];
+    } else {
+      return [buildMemberExpression([localSymbol ?? targetDeclaration]), localSymbol ?? targetDeclaration];
+    }
+  });
+}
+function buildMemberExpression(path) {
+  let memberExpr = "";
+  const base = path[0];
+  if (base.flags & OutputSymbolFlags.InstanceMember) {
+    memberExpr += "self";
+  } else {
+    memberExpr += base.name;
+    path = path.slice(1);
+  }
+  for (const sym of path) {
+    memberExpr += `.${sym.name}`;
+  }
+  return memberExpr;
+}

package/dist/src/symbols/scopes.d.ts

@@ -0,0 +1,5 @@
+import { PythonMemberScope } from "./python-member-scope.js";
+import { PythonModuleScope } from "./python-module-scope.js";
+export type PythonOutputScope = PythonModuleScope | PythonMemberScope;
+export declare function usePythonScope(): PythonOutputScope;
+//# sourceMappingURL=scopes.d.ts.map

package/dist/src/symbols/scopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scopes.d.ts","sourceRoot":"","sources":["../../../src/symbols/scopes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;AAEtE,wBAAgB,cAAc,IACP,iBAAiB,CACvC"}

package/dist/src/symbols/scopes.js

@@ -0,0 +1,4 @@
+import { useScope } from "@alloy-js/core";
+export function usePythonScope() {
+  return useScope();
+}

package/dist/src/utils.d.ts

@@ -0,0 +1,7 @@
+import { CallSignatureProps } from "./components/index.js";
+/**
+ * Extract only the call signature props from a props object which extends
+ * `CallSignatureProps`. You can provide default values for the props.
+ */
+export declare function getCallSignatureProps(props: CallSignatureProps, defaults?: Partial<CallSignatureProps>): CallSignatureProps;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,kBAAkB,EACzB,QAAQ,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,sBAiBvC"}

package/dist/src/utils.js

@@ -0,0 +1,12 @@
+import { defaultProps, splitProps } from "@alloy-js/core";
+/**
+ * Extract only the call signature props from a props object which extends
+ * `CallSignatureProps`. You can provide default values for the props.
+ */
+export function getCallSignatureProps(props, defaults) {
+  const [callSignatureProps] = splitProps(props, ["parameters", "typeParameters", "args", "kwargs", "instanceFunction", "classFunction", "returnType"]);
+  if (!defaults) {
+    return callSignatureProps;
+  }
+  return defaultProps(callSignatureProps, defaults);
+}

package/dist/test/callsignatures.test.d.ts

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

package/dist/test/callsignatures.test.d.ts.map

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

package/dist/test/callsignatures.test.js

@@ -0,0 +1,276 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { toSourceText } from "./utils.js";
+describe("Call Signature Parameters", () => {
+  it("renders simple function parameters", () => {
+    const result = toSourceText([_$createComponent(py.CallSignatureParameters, {
+      parameters: ["a", "b"]
+    })]);
+    expect(result).toRenderTo(d`
+      a, b
+    `);
+  });
+  it("renders ParameterDescriptor parameters", () => {
+    const result = toSourceText([_$createComponent(py.CallSignatureParameters, {
+      parameters: [{
+        name: "a"
+      }, {
+        name: "b"
+      }]
+    })]);
+    expect(result).toRenderTo(d`
+      a, b
+    `);
+  });
+  it("renders ParameterDescriptor parameters with types", () => {
+    const result = toSourceText([_$createComponent(py.CallSignatureParameters, {
+      parameters: [{
+        name: "a",
+        type: "int"
+      }, {
+        name: "b",
+        type: "str"
+      }]
+    })]);
+    expect(result).toRenderTo(d`
+      a: int, b: str
+    `);
+  });
+  it("renders optional ParameterDescriptor parameters with types", () => {
+    const result = toSourceText([_$createComponent(py.CallSignatureParameters, {
+      parameters: [{
+        name: "a",
+        type: "int",
+        optional: true
+      }, {
+        name: "b",
+        type: "str",
+        optional: true
+      }]
+    })]);
+    expect(result).toRenderTo(d`
+      a: int = None, b: str = None
+    `);
+  });
+  it("renders optional ParameterDescriptor parameters default", () => {
+    const result = toSourceText([_$createComponent(py.CallSignatureParameters, {
+      parameters: [{
+        name: "a",
+        default: 5
+      }, {
+        name: "b",
+        default: "hello"
+      }]
+    })]);
+    expect(result).toRenderTo(d`
+      a=5, b="hello"
+    `);
+  });
+  it("renders optional ParameterDescriptor parameters with types and default", () => {
+    const result = toSourceText([_$createComponent(py.CallSignatureParameters, {
+      parameters: [{
+        name: "a",
+        type: "int",
+        optional: true,
+        default: 5
+      }, {
+        name: "b",
+        type: "str",
+        optional: true,
+        default: "hello"
+      }]
+    })]);
+    expect(result).toRenderTo(d`
+      a: int = 5, b: str = "hello"
+    `);
+  });
+});
+describe("Call Signature", () => {
+  it("renders a simple call signature", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: ["a", "b"]
+    })]);
+    expect(result).toRenderTo(d`
+      (a, b)
+    `);
+  });
+  it("renders a simple call signature with args and kwargs", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: ["a", "b"],
+      args: true,
+      kwargs: true
+    })]);
+    expect(result).toRenderTo(d`
+      (a, b, *args, **kwargs)
+    `);
+  });
+  it("renders a simple call signature with type parameters", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: ["a", "b"],
+      typeParameters: ["T", "U"]
+    })]);
+    expect(result).toRenderTo(d`
+      [T, U](a, b)
+    `);
+  });
+  it("renders a simple call signature with return type", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: ["a", "b"],
+      returnType: "int"
+    })]);
+    expect(result).toRenderTo(d`
+      (a, b) -> int
+    `);
+  });
+  it("renders a simple call signature for a class function", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: ["a", "b"],
+      classFunction: true
+    })]);
+    expect(result).toRenderTo(d`
+      (cls, a, b)
+    `);
+  });
+  it("renders a simple call signature for an instance function", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: ["a", "b"],
+      instanceFunction: true
+    })]);
+    expect(result).toRenderTo(d`
+      (self, a, b)
+    `);
+  });
+  it("throws an error for a call signature that's instance and class function at the same time", () => {
+    expect(() => toSourceText([_$createComponent(py.CallSignature, {
+      parameters: ["a", "b"],
+      instanceFunction: true,
+      classFunction: true
+    })])).toThrowError(/Cannot be both an instance function and a class function/);
+  });
+  it("renders a simple call signature with all properties", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: ["a", "b"],
+      instanceFunction: true,
+      args: true,
+      kwargs: true,
+      returnType: "int"
+    })]);
+    expect(result).toRenderTo(d`
+      (self, a, b, *args, **kwargs) -> int
+    `);
+  });
+});
+describe("Call Signature - Parameter Descriptors", () => {
+  it("renders a call signature with parameter descriptors", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: [{
+        name: "a",
+        type: "int"
+      }, {
+        name: "b",
+        type: "str"
+      }]
+    })]);
+    expect(result).toRenderTo(d`
+      (a: int, b: str)
+    `);
+  });
+  it("renders a call signature with parameter descriptors, args and kwargs", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: [{
+        name: "a",
+        type: "int"
+      }, {
+        name: "b",
+        type: "str"
+      }],
+      args: true,
+      kwargs: true
+    })]);
+    expect(result).toRenderTo(d`
+      (a: int, b: str, *args, **kwargs)
+    `);
+  });
+  it("renders a call signature with parameter descriptors and return type", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: [{
+        name: "a",
+        type: "int"
+      }, {
+        name: "b",
+        type: "str"
+      }],
+      returnType: "int"
+    })]);
+    expect(result).toRenderTo(d`
+      (a: int, b: str) -> int
+    `);
+  });
+  it("renders a call signature with parameter descriptors for a class function", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: [{
+        name: "a",
+        type: "int"
+      }, {
+        name: "b",
+        type: "str"
+      }],
+      classFunction: true
+    })]);
+    expect(result).toRenderTo(d`
+      (cls, a: int, b: str)
+    `);
+  });
+  it("renders a call signature with parameter descriptors for an instance function", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: [{
+        name: "a",
+        type: "int"
+      }, {
+        name: "b",
+        type: "str"
+      }],
+      instanceFunction: true
+    })]);
+    expect(result).toRenderTo(d`
+      (self, a: int, b: str)
+    `);
+  });
+  it("renders a call signature with all", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      parameters: [{
+        name: "a",
+        type: "int"
+      }, {
+        name: "b",
+        type: "str"
+      }],
+      instanceFunction: true,
+      args: true,
+      kwargs: true,
+      returnType: "int"
+    })]);
+    expect(result).toRenderTo(d`
+      (self, a: int, b: str, *args, **kwargs) -> int
+    `);
+  });
+  it("renders a more complex call signature with parameter descriptors", () => {
+    const result = toSourceText([_$createComponent(py.CallSignature, {
+      typeParameters: ["T", "U"],
+      parameters: [{
+        name: "a",
+        type: "int"
+      }, {
+        name: "b",
+        type: "str",
+        default: "default_value"
+      }],
+      returnType: "int"
+    })]);
+    expect(result).toRenderTo(d`
+      [T, U](a: int, b: str = "default_value") -> int
+    `);
+  });
+});

package/dist/test/classdeclarations.test.d.ts

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

package/dist/test/classdeclarations.test.d.ts.map

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