@alloy-js/core 0.10.0 → 0.12.0

package/dist/test/rendering/refkeys.test.js

@@ -0,0 +1,32 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { refkey } from "@alloy-js/core";
+import { SourceFile } from "@alloy-js/core/stc";
+import { expect, it } from "vitest";
+import "../../testing/extend-expect.js";
+it("is rendered properly in the tree", () => {
+  const key = refkey("foo");
+  function Reference(props) {
+    expect(props.refkey).toEqual(key);
+    return "Reference";
+  }
+  expect(_$createComponent(SourceFile, {
+    filetype: "typescript",
+    path: "foo.ts",
+    reference: Reference,
+    children: key
+  })).toRenderTo("Reference");
+});
+it("is rendered properly in the tree with code", () => {
+  const key = refkey("foo");
+  function Reference(props) {
+    expect(props.refkey).toEqual(key);
+    return "Reference";
+  }
+  expect(SourceFile({
+    filetype: "typescript",
+    path: "foo.ts",
+    reference: Reference
+  }).code`
+      ${key} 
+    `).toRenderTo("Reference");
+});

package/dist/test/split-props.test.js

@@ -0,0 +1,77 @@
+import { effect, reactive } from "@vue/reactivity";
+import { expect, it, vi } from "vitest";
+import { splitProps } from "../src/jsx-runtime.js";
+it("splits regular object props", () => {
+  const props = {
+    a: 1,
+    b: 2,
+    c: 3
+  };
+  const [ab, rest] = splitProps(props, ["a", "b"]);
+  expect(ab).toEqual({
+    a: 1,
+    b: 2
+  });
+  expect(rest).toEqual({
+    c: 3
+  });
+});
+it("splits props with getters without invoking them", () => {
+  const getterA = vi.fn(() => 1);
+  const getterB = vi.fn(() => 2);
+  const props = {
+    get a() {
+      return getterA();
+    },
+    get b() {
+      return getterB();
+    },
+    c: 3
+  };
+  const [ab, rest] = splitProps(props, ["a", "b"]);
+  expect(getterA).not.toHaveBeenCalled();
+  expect(getterB).not.toHaveBeenCalled();
+  expect(ab.a).toBe(1);
+  expect(getterA).toHaveBeenCalledTimes(1);
+  expect(ab.b).toBe(2);
+  expect(getterB).toHaveBeenCalledTimes(1);
+  expect(rest).toEqual({
+    c: 3
+  });
+});
+it("splits reactive props without observing them initially", () => {
+  const props = reactive({
+    a: 1,
+    b: 2,
+    c: 3
+  });
+  const [ab, rest] = splitProps(props, ["a", "b"]);
+  expect(ab.a).toBe(1);
+  expect(ab.b).toBe(2);
+  expect(rest.c).toBe(3);
+});
+it("ensures effect is not triggered by splitProps but by accessing reactive props", () => {
+  const props = reactive({
+    a: 1,
+    b: 2,
+    c: 3
+  });
+  let splits;
+  const splitEffect = vi.fn(() => {
+    splits = splitProps(props, ["a", "b"]);
+  });
+  effect(splitEffect);
+  expect(splitEffect).toHaveBeenCalledTimes(1);
+  const observeEffect = vi.fn(() => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    splits[0].a;
+  });
+  effect(observeEffect);
+  expect(observeEffect).toHaveBeenCalledTimes(1);
+  props.a = 2;
+  expect(splitEffect).toHaveBeenCalledTimes(1);
+  expect(observeEffect).toHaveBeenCalledTimes(2);
+  splits[0].a = 3;
+  expect(splitEffect).toHaveBeenCalledTimes(1);
+  expect(observeEffect).toHaveBeenCalledTimes(3);
+});

package/dist/test/stc.test.js

@@ -0,0 +1,34 @@
+import { stc } from "@alloy-js/core";
+import { hbr, indent, Indent } from "@alloy-js/core/stc";
+import { describe, expect, it } from "vitest";
+import "../testing/extend-expect.js";
+it("is applied by output", () => {
+  function Foo() {
+    return "Foo component";
+  }
+  const FooStc = stc(Foo);
+  expect([FooStc(), Indent().code`
+      child!
+      child2!
+    `]).toRenderTo(`
+    Foo component
+      child!
+      child2!
+  `);
+});
+describe("works with formatting", () => {
+  it("handles lines", () => {
+    expect(["foo", hbr(), "bar", hbr(), "baz"]).toRenderTo(`
+      foo
+      bar
+      baz
+    `);
+  });
+  it("handles indents", () => {
+    expect(["foo", indent().children([hbr(), "bar", hbr(), "baz"])]).toRenderTo(`
+      foo
+        bar
+        baz
+    `);
+  });
+});