@alloy-js/csharp 0.20.0-dev.1 → 0.20.0-dev.10

package/dist/test/enum.test.js

@@ -1,178 +0,0 @@
-import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
-import * as core from "@alloy-js/core";
-import * as coretest from "@alloy-js/core/testing";
-import { expect, it } from "vitest";
-import * as csharp from "../src/index.js";
-import * as utils from "./utils.js";
-import { findFile } from "./utils.js";
-it("declares enum with no members", () => {
-  const res = utils.toSourceText(_$createComponent(csharp.EnumDeclaration, {
-    "public": true,
-    name: "TestEnum"
-  }));
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum;
-    }
-  `);
-});
-it("declares enum with members", () => {
-  const res = utils.toSourceText(_$createComponent(csharp.EnumDeclaration, {
-    "public": true,
-    name: "TestEnum",
-    get children() {
-      return [_$createComponent(csharp.EnumMember, {
-        name: "One"
-      }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
-        name: "Two"
-      })];
-    }
-  }));
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-    }
-  `);
-});
-it("applies naming policy to enum and members", () => {
-  const res = utils.toSourceText(_$createComponent(csharp.EnumDeclaration, {
-    "public": true,
-    name: "testEnum",
-    get children() {
-      return [_$createComponent(csharp.EnumMember, {
-        name: "one"
-      }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
-        name: "two"
-      })];
-    }
-  }));
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-    }
-  `);
-});
-it("can reference things by refkey", () => {
-  const enumRK = core.refkey();
-  const twoRK = core.refkey();
-  const res = core.render(_$createComponent(core.Output, {
-    get children() {
-      return _$createComponent(csharp.Namespace, {
-        name: "TestCode",
-        get children() {
-          return _$createComponent(csharp.SourceFile, {
-            path: "Test.cs",
-            get children() {
-              return [_$createComponent(csharp.EnumDeclaration, {
-                "public": true,
-                name: "TestEnum",
-                refkey: enumRK,
-                get children() {
-                  return [_$createComponent(csharp.EnumMember, {
-                    name: "One"
-                  }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
-                    name: "Two",
-                    refkey: twoRK
-                  })];
-                }
-              }), _$createIntrinsic("hbr", {}), enumRK, ";", _$createIntrinsic("hbr", {}), twoRK, ";"];
-            }
-          });
-        }
-      });
-    }
-  }));
-  expect(findFile(res, "Test.cs").contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-        TestEnum;
-        TestEnum.Two;
-    }
-  `);
-});
-it("can reference things by refkey across files", () => {
-  const enumRK = core.refkey();
-  const barRK = core.refkey();
-  const res = core.render(_$createComponent(core.Output, {
-    get children() {
-      return _$createComponent(csharp.Namespace, {
-        name: "TestCode",
-        get children() {
-          return [_$createComponent(csharp.SourceFile, {
-            path: "Test.cs",
-            get children() {
-              return [_$createComponent(csharp.EnumDeclaration, {
-                "public": true,
-                name: "TestEnum",
-                get children() {
-                  return [_$createComponent(csharp.EnumMember, {
-                    name: "One"
-                  }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
-                    name: "Two"
-                  })];
-                }
-              }), _$createIntrinsic("hbr", {}), enumRK, ";", _$createIntrinsic("hbr", {}), barRK, ";"];
-            }
-          }), _$createComponent(csharp.SourceFile, {
-            path: "Other.cs",
-            get children() {
-              return [_$createComponent(csharp.EnumDeclaration, {
-                "public": true,
-                name: "OtherEnum",
-                refkey: enumRK,
-                get children() {
-                  return [_$createComponent(csharp.EnumMember, {
-                    name: "Foo"
-                  }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
-                    name: "Bar",
-                    refkey: barRK
-                  })];
-                }
-              }), _$createIntrinsic("hbr", {}), enumRK, ";", _$createIntrinsic("hbr", {}), barRK, ";"];
-            }
-          })];
-        }
-      });
-    }
-  }));
-  expect(findFile(res, "Test.cs").contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-        OtherEnum;
-        OtherEnum.Bar;
-    }
-  `);
-  expect(findFile(res, "Other.cs").contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum OtherEnum
-        {
-            Foo,
-            Bar
-        }
-        OtherEnum;
-        OtherEnum.Bar;
-    }
-  `);
-});

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

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

package/dist/test/namespace.test.js

@@ -1,81 +0,0 @@
-import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
-import * as core from "@alloy-js/core";
-import * as coretest from "@alloy-js/core/testing";
-import { it } from "vitest";
-import * as csharp from "../src/index.js";
-import { assertFileContents } from "./utils.js";
-it("defines multiple namespaces and source files with unique content", () => {
-  const res = core.render(_$createComponent(core.Output, {
-    get children() {
-      return [_$createComponent(csharp.Namespace, {
-        name: "Namespace1",
-        get children() {
-          return [_$createComponent(csharp.SourceFile, {
-            path: "Model1.cs",
-            get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
-                name: "Model1"
-              });
-            }
-          }), _$createComponent(csharp.SourceFile, {
-            path: "Model2.cs",
-            get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
-                name: "Model2"
-              });
-            }
-          })];
-        }
-      }), _$createComponent(csharp.Namespace, {
-        name: "Namespace2",
-        get children() {
-          return [_$createComponent(csharp.SourceFile, {
-            path: "Model3.cs",
-            get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
-                name: "Model3"
-              });
-            }
-          }), _$createComponent(csharp.SourceFile, {
-            path: "Model4.cs",
-            get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
-                name: "Model4"
-              });
-            }
-          })];
-        }
-      })];
-    }
-  }));
-  assertFileContents(res, {
-    "Model1.cs": coretest.d`
-      namespace Namespace1
-      {
-          public class Model1;
-      }
-    `,
-    "Model2.cs": coretest.d`
-      namespace Namespace1
-      {
-          public class Model2;
-      }
-    `,
-    "Model3.cs": coretest.d`
-      namespace Namespace2
-      {
-          public class Model3;
-      }
-    `,
-    "Model4.cs": coretest.d`
-      namespace Namespace2
-      {
-          public class Model4;
-      }
-    `
-  });
-});

package/dist/test/sourcefile.test.d.ts

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

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

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

package/dist/test/sourcefile.test.js

@@ -1,58 +0,0 @@
-import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
-import * as core from "@alloy-js/core";
-import * as coretest from "@alloy-js/core/testing";
-import { expect, it } from "vitest";
-import * as csharp from "../src/index.js";
-import { assertFileContents } from "./utils.js";
-it("defines multiple source files with unique content", () => {
-  const res = core.render(_$createComponent(core.Output, {
-    get children() {
-      return _$createComponent(csharp.Namespace, {
-        name: "TestCode",
-        get children() {
-          return [_$createComponent(csharp.SourceFile, {
-            path: "Test1.cs",
-            get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
-                name: "TestClass1"
-              });
-            }
-          }), _$createComponent(csharp.SourceFile, {
-            path: "Test2.cs",
-            get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
-                name: "TestClass2"
-              });
-            }
-          })];
-        }
-      });
-    }
-  }));
-  assertFileContents(res, {
-    "Test1.cs": coretest.d`
-      namespace TestCode
-      {
-          public class TestClass1;
-      }
-    `,
-    "Test2.cs": coretest.d`
-      namespace TestCode
-      {
-          public class TestClass2;
-      }
-    `
-  });
-});
-it("throws when declaring a source file outside a namespace", () => {
-  const decl = _$createComponent(core.Output, {
-    get children() {
-      return _$createComponent(csharp.SourceFile, {
-        path: "Test.cs"
-      });
-    }
-  });
-  expect(() => core.render(decl)).toThrow("SourceFile must be declared inside a namespace");
-});

package/src/components/EnumDeclaration.tsx

@@ -1,99 +0,0 @@
-import * as core from "@alloy-js/core";
-import {
-  AccessModifiers,
-  computeModifiersPrefix,
-  getAccessModifier,
-} from "../modifiers.js";
-import { useCSharpNamePolicy } from "../name-policy.js";
-import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
-import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
-import { Name } from "./Name.jsx";
-
-// properties for creating an enum
-export interface EnumDeclarationProps extends AccessModifiers {
-  name: string;
-  refkey?: core.Refkey;
-  children?: core.Children;
-}
-
-/**
- * A C# enum declaration
- * @example
- * ```tsx
- * <EnumDeclaration public name="Color">
- *   <EnumMember name="Red" />
- *   <EnumMember name="Green" />
- *   <EnumMember name="Blue" />
- * </EnumDeclaration>
- * ```
- * This will produce:
- * ```csharp
- * public enum Color
- * {
- *   Red,
- *   Green,
- *   Blue
- * }
- * ```
- */
-export function EnumDeclaration(props: EnumDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "enum");
-  const scope = useCSharpScope();
-
-  const thisEnumSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? core.refkey(props.name),
-  });
-
-  // this creates a new scope for the enum definition.
-  // members will automatically "inherit" this scope so
-  // that refkeys to them will produce the fully-qualified
-  // name e.g. Foo.Bar.
-  const thisEnumScope = new CSharpMemberScope("enum-decl", {
-    parent: scope,
-    owner: thisEnumSymbol,
-  });
-
-  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
-
-  if (thisEnumScope.owner)
-    return (
-      <core.Declaration symbol={thisEnumSymbol}>
-        {modifiers}enum <Name />
-        {!props.children && ";"}
-        {props.children && (
-          <core.Scope value={thisEnumScope}>
-            <core.Block newline>{props.children}</core.Block>
-          </core.Scope>
-        )}
-      </core.Declaration>
-    );
-}
-
-// properties for creating a C# enum member
-export interface EnumMemberProps {
-  name: string;
-  refkey?: core.Refkey;
-}
-
-// a member within a C# enum
-export function EnumMember(props: EnumMemberProps) {
-  const scope = useCSharpScope();
-  if (scope.kind === "member" && scope.name !== "enum-decl") {
-    throw new Error(
-      "can't define an enum member outside of an enum-decl scope",
-    );
-  }
-
-  const name = useCSharpNamePolicy().getName(props.name, "enum-member");
-  const thisEnumValueSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? core.refkey(props.name),
-  });
-
-  return (
-    <core.Declaration symbol={thisEnumValueSymbol}>
-      <Name />
-    </core.Declaration>
-  );
-}

package/src/components/Namespace.tsx

@@ -1,35 +0,0 @@
-import * as core from "@alloy-js/core";
-import { CSharpNamespaceScope } from "../symbols/scopes.js";
-
-// contains the info for the current namespace
-export interface NamespaceContext {
-  name: string;
-}
-
-const NamespaceContext = core.createContext<NamespaceContext>();
-
-// returns the current namespace
-export function useNamespace(): NamespaceContext | undefined {
-  return core.useContext(NamespaceContext) as NamespaceContext;
-}
-
-// properties for creating a C# namespace
-export interface NamespaceProps {
-  name: string;
-  children?: core.Children;
-}
-
-// a C# namespace. contains one or more source files
-export function Namespace(props: NamespaceProps) {
-  const scope = new CSharpNamespaceScope(props.name);
-
-  const namespaceCtx: NamespaceContext = {
-    name: props.name,
-  };
-
-  return (
-    <NamespaceContext.Provider value={namespaceCtx}>
-      <core.Scope value={scope}>{props.children}</core.Scope>
-    </NamespaceContext.Provider>
-  );
-}

package/src/components/SourceFile.tsx

@@ -1,78 +0,0 @@
-import * as core from "@alloy-js/core";
-import { useNamespace } from "./Namespace.jsx";
-import { Reference } from "./Reference.jsx";
-import { UsingDirective } from "./UsingDirective.jsx";
-
-// contains the info for the current source file
-export interface SourceFileContext {
-  // adds a namespace to the array of using statements
-  addUsing(namespace: string): void;
-}
-
-const SourceFileContext = core.createContext<SourceFileContext>();
-
-// returns the current source file
-export function useSourceFile(): SourceFileContext | undefined {
-  return core.useContext(SourceFileContext) as SourceFileContext;
-}
-
-export interface SourceFileProps {
-  /** Path of the source file */
-  path: string;
-
-  /** A list of namespaces to use */
-  using?: Array<string>;
-
-  children?: core.Children;
-}
-
-// a C# source file. exists within the context of a namespace
-// contains using statements and declarations
-export function SourceFile(props: SourceFileProps) {
-  const namespaceCtx = useNamespace();
-
-  if (!namespaceCtx) {
-    throw new Error("SourceFile must be declared inside a namespace");
-  }
-
-  const using: Array<string> = core.reactive(new Array<string>());
-  if (props.using) {
-    using.push(...props.using);
-  }
-
-  // adds the specified namespace to the array of using statements.
-  // called via SourceFileContext.addUsing when resolving refkeys.
-  function addUsing(namespace: string): void {
-    if (!using.includes(namespace)) {
-      using.push(namespace);
-    }
-  }
-
-  const sourceFileCtx: SourceFileContext = {
-    addUsing,
-  };
-
-  return (
-    <core.SourceFile
-      path={props.path}
-      filetype="cs"
-      reference={Reference}
-      tabWidth={4}
-      printWidth={120}
-    >
-      <SourceFileContext.Provider value={sourceFileCtx}>
-        <core.Scope name={props.path} kind="source-file">
-          {using.length > 0 && (
-            <>
-              <UsingDirective namespaces={using} />
-              <hbr />
-              <hbr />
-            </>
-          )}
-          namespace {namespaceCtx.name}
-          <core.Block newline>{props.children}</core.Block>
-        </core.Scope>
-      </SourceFileContext.Provider>
-    </core.SourceFile>
-  );
-}

package/src/symbols/csharp-output-symbol.ts

@@ -1,22 +0,0 @@
-import * as core from "@alloy-js/core";
-import { useNamespace } from "../components/Namespace.jsx";
-import { CSharpOutputScope } from "./scopes.js";
-
-// represents a symbol from a .cs file. Class, enum, interface etc.
-
-export class CSharpOutputSymbol extends core.OutputSymbol {
-  get scope() {
-    return super.scope as CSharpOutputScope;
-  }
-  set scope(value: CSharpOutputScope) {
-    super.scope = value;
-  }
-
-  constructor(name: string, options?: core.OutputSymbolOptions) {
-    const namespaceCtx = useNamespace();
-    if (!namespaceCtx) {
-      throw new Error("symbol must be declared inside a namespace");
-    }
-    super(name, options);
-  }
-}

package/src/symbols/reference.ts

@@ -1,65 +0,0 @@
-import * as core from "@alloy-js/core";
-import { useNamespace } from "../components/Namespace.jsx";
-import { useSourceFile } from "../components/SourceFile.jsx";
-import { CSharpOutputSymbol } from "./csharp-output-symbol.js";
-import { CSharpOutputScope } from "./scopes.js";
-
-// when resolving references across source files, the last element
-// in pathDown will be the containing source file. we only need this
-// here so we can find and remove this scope as it's not useful
-// when building the reference
-interface SourceFileScope extends core.OutputScope {
-  kind: "source-file";
-}
-
-type ReferenceScope = CSharpOutputScope | SourceFileScope;
-
-// converts a refkey to its fully qualified name
-// e.g. if refkey is for bar in enum type foo, and
-// foo is in the same namespace as the refkey, then
-// the result would be foo.bar.
-export function ref(refkey: core.Refkey): () => string {
-  const targetNamespaceCtx = useNamespace();
-  const resolveResult = core.resolve<ReferenceScope, CSharpOutputSymbol>(
-    refkey as core.Refkey,
-  );
-
-  return core.memo(() => {
-    if (resolveResult.value === undefined) {
-      return "<Unresolved Symbol>";
-    }
-
-    // targetDeclaration is the symbol with the refkey
-    // pathDown is an array of scopes to that symbol and can be empty.
-    // the entries are top-down, so namespace, source-file, member
-    //  - referencing a type within the same namespace will have an empty path
-    //  - referencing a member (e.g. enum value) within the same namespace will
-    //    have a single path entry that contains the owning type
-    //  - referencing a type within the same namespace but in a different source
-    //    file will have at least a source-file entry
-    //  - referencing a symbol outside the current namespace will have at least
-    //    two entries, namespace, source-file
-    const { targetDeclaration, pathDown } = resolveResult.value;
-
-    const sourceNamespace = pathDown.find((v) => {
-      return v.kind === "namespace";
-    });
-    if (sourceNamespace && sourceNamespace.name !== targetNamespaceCtx!.name) {
-      // the source symbol is in a different namespace that the target refkey.
-      // add the applicable using statement to the target's source file.
-      const targetSrc = useSourceFile();
-      targetSrc!.addUsing(sourceNamespace.name);
-    }
-
-    // we only need to build the fully-qualified name for members
-    // TODO: possibly a subset of members
-    const syms = (pathDown as ReferenceScope[])
-      .filter((v) => {
-        return v.kind === "member";
-      })
-      .map((s) => s.owner!);
-    syms.push(targetDeclaration);
-
-    return syms.map((sym) => sym.name).join(".");
-  });
-}

package/src/symbols/scopes.ts

@@ -1,41 +0,0 @@
-import * as core from "@alloy-js/core";
-import { CSharpOutputSymbol } from "./csharp-output-symbol.js";
-
-// indicates that the scope for a symbols is at the namespace level
-export class CSharpNamespaceScope extends core.OutputScope {
-  get kind() {
-    return "namespace";
-  }
-}
-
-// the kind of member scope. i.e. are we in an enum, class, etc
-export type CSharpMemberScopeName =
-  | "class-decl"
-  | "constructor-decl"
-  | "enum-decl"
-  | "method-decl";
-
-// indicates that the scope for a symbol resides within a type
-// e.g. for an enum value, class field etc, these would have
-// member scope where the owner is the containing type.
-export class CSharpMemberScope extends core.OutputScope {
-  get kind() {
-    return "member";
-  }
-
-  get name() {
-    return super.name as CSharpMemberScopeName;
-  }
-
-  get owner() {
-    return super.owner as CSharpOutputSymbol;
-  }
-}
-
-// contains the possible scopes where a declaration can reside
-export type CSharpOutputScope = CSharpMemberScope | CSharpNamespaceScope;
-
-// returns the current C# scope
-export function useCSharpScope(): CSharpOutputScope {
-  return core.useScope() as CSharpOutputScope;
-}