@alloy-js/core 0.7.0 → 0.8.0

package/test/components/declaration.test.tsx

@@ -19,7 +19,7 @@ it("creates and cleans up a symbol", () => {
   const template = (
     <Output>
       <GetBinder />
-      <Scope>
+      <Scope name="foo">
         {doDecl.value ?
           <Declaration name="foo"></Declaration>
         : ""}

package/test/components/prose.test.tsx

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { Prose } from "../../src/components/Prose.jsx";
+import "../../testing/extend-expect.js";
+import { d } from "../../testing/render.js";
+
+describe("Prose", () => {
+  it("formats properly", () => {
+    const template = (
+      <>
+        <Prose>
+          This is a long paragraph that should end up being broken into multiple
+          lines.
+        </Prose>
+        <hbr />
+        <hbr />
+        <Prose>
+          This is another paragraph. There should be a couple breaks in front of
+          it.
+        </Prose>
+      </>
+    );
+
+    expect(template).toRenderTo(
+      d`
+        This is a long paragraph that
+        should end up being broken
+        into multiple lines.
+
+        This is another paragraph.
+        There should be a couple
+        breaks in front of it. 
+      `,
+      { printWidth: 30 },
+    );
+  });
+});

package/test/components/source-file.test.tsx

@@ -9,6 +9,7 @@ import {
 import { expect, it } from "vitest";
 import { SourceDirectoryContext } from "../../src/context/source-directory.js";
 import "../../testing/extend-expect.js";
+import { d } from "../../testing/render.js";
 
 it("tracks its content", () => {
   let context;
@@ -51,3 +52,19 @@ it("has reactive context", () => {
 
   expect(tree.contents[1].contents).toEqual("hi.txt contents.txt");
 });
+
+it("Includes header", () => {
+  const header = <># This is a header</>;
+  const tree = render(
+    <Output>
+      <SourceFile path="hi.txt" filetype="text" header={header}>
+        hello!
+      </SourceFile>
+    </Output>,
+  );
+
+  expect(tree.contents[0].contents).toEqual(d`
+    # This is a header
+    hello!
+    `);
+});

package/test/props-with-defaults.test.ts

@@ -0,0 +1,97 @@
+import { effect, reactive } from "@vue/reactivity";
+import { expect, it, vi } from "vitest";
+import { defaultProps } from "../src/jsx-runtime.js";
+
+it("applies defaults to regular object props", () => {
+  const props = {
+    a: 1,
+    b: 2,
+    c: undefined as number | undefined,
+  };
+
+  const dProps = defaultProps(props, { a: 10, c: 20 });
+
+  expect(dProps).toEqual({ a: 1, b: 2, c: 20 });
+});
+
+it("applies defaults with getters without invoking them", () => {
+  const getterA = vi.fn(() => 1);
+  const getterB = vi.fn(() => undefined as number | undefined);
+  const props = {
+    get a() {
+      return getterA();
+    },
+    get b() {
+      return getterB();
+    },
+    c: 3,
+  };
+
+  const dProps = defaultProps(props, { b: 20, c: 30 });
+
+  expect(getterA).not.toHaveBeenCalled();
+  expect(getterB).not.toHaveBeenCalled();
+
+  const value = dProps.b;
+  expect(getterB).toHaveBeenCalledTimes(1);
+  expect(value).toEqual(20);
+});
+
+it("applies defaults to reactives without observing them initially", () => {
+  const props = reactive({
+    a: 1,
+    b: 2,
+    c: undefined as number | undefined,
+  });
+
+  const defaults = defaultProps(props, { c: 10 });
+
+  expect(defaults.a).toBe(1);
+  expect(defaults.b).toBe(2);
+  expect(defaults.c).toBe(10);
+});
+
+it("ensures effect is not triggered by defaults but by accessing reactive props", () => {
+  const props = reactive({
+    a: 1,
+    b: 2,
+    c: undefined as number | undefined,
+  });
+
+  let withDefaults: any;
+  const splitEffect = vi.fn(() => {
+    withDefaults = defaultProps(props, { c: 10 });
+  });
+
+  effect(splitEffect);
+  expect(splitEffect).toHaveBeenCalledTimes(1);
+
+  const observeEffect = vi.fn(() => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    withDefaults.a;
+  });
+  effect(observeEffect);
+  expect(observeEffect).toHaveBeenCalledTimes(1);
+
+  props.a = 2;
+  expect(splitEffect).toHaveBeenCalledTimes(1);
+  expect(observeEffect).toHaveBeenCalledTimes(2);
+});
+
+it("applies defaults to reactives", () => {
+  const props = reactive({
+    a: 1,
+    b: 2,
+    c: undefined as number | undefined,
+  });
+
+  const withDefaults = defaultProps(props, { c: 10 });
+
+  expect(withDefaults.c).toBe(10);
+  props.c = 20;
+
+  expect(withDefaults.c).toBe(20);
+  props.c = undefined;
+
+  expect(withDefaults.c).toBe(10);
+});

package/test/symbols.test.ts

@@ -296,31 +296,6 @@ describe("instance members", () => {
     expect(pathUp).toEqual([]);
     expect(memberPath).toEqual([instance]);
   });
-
-  it("doesn't resolve from outside the member scope", () => {
-    const binder = createOutputBinder();
-    const {
-      scopes: { root },
-      symbols: { instance },
-    } = createScopeTree(binder, {
-      root: {
-        symbols: {
-          root: {
-            flags: OutputSymbolFlags.InstanceMemberContainer,
-            instanceMembers: {
-              instance: {
-                flags: OutputSymbolFlags.InstanceMember,
-              },
-            },
-          },
-        },
-      },
-    });
-
-    expect(() =>
-      binder.resolveDeclarationByKey(root, undefined, instance.refkeys[0]),
-    ).toThrow(/Cannot resolve member symbols/);
-  });
 });
 
 describe("instantiating members", () => {

package/vitest.config.ts

@@ -1,4 +1,4 @@
-import { babel } from "@rollup/plugin-babel";
+import alloyPlugin from "@alloy-js/rollup-plugin";
 import { defineConfig } from "vitest/config";
 
 export default defineConfig({
@@ -6,13 +6,5 @@ export default defineConfig({
     jsx: "preserve",
     sourcemap: "both",
   },
-  plugins: [
-    babel({
-      inputSourceMap: true as any,
-      sourceMaps: "both",
-      babelHelpers: "bundled",
-      extensions: [".ts", ".tsx"],
-      presets: ["@babel/preset-typescript", ["@alloy-js/babel-preset"]],
-    }),
-  ],
+  plugins: [alloyPlugin()],
 });