@alloy-js/core 0.10.0 → 0.12.0

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

@@ -1 +1 @@
-{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../test/utils.test.tsx"],"names":[],"mappings":"AAKA,OAAO,6BAA6B,CAAC"}
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../test/utils.test.tsx"],"names":[],"mappings":"AAMA,OAAO,6BAA6B,CAAC"}

package/dist/test/utils.test.js

@@ -0,0 +1,223 @@
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { computed, ref, triggerRef } from "@vue/reactivity";
+import { describe, expect, it } from "vitest";
+import { renderTree } from "../src/render.js";
+import { flushJobs } from "../src/scheduler.js";
+import { children, join, mapJoin } from "../src/utils.js";
+import "../testing/extend-expect.js";
+describe("mapJoin", () => {
+  it("can map a map", () => {
+    const map = new Map([["a", 1], ["b", 2]]);
+    function Foo(props) {
+      return ["Key: ", _$memo(() => props.key), ", Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => map, (key, value) => _$createComponent(Foo, {
+      key: key,
+      value: value
+    }));
+    expect(joined()).toRenderTo(`
+      Key: a, Value: 1
+      Key: b, Value: 2
+    `);
+  });
+  it("can map an array", () => {
+    const arr = [1, 2];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr, value => _$createComponent(Foo, {
+      value: value
+    }));
+    expect(joined()).toRenderTo(`
+      Value: 1
+      Value: 2
+    `);
+  });
+  it("can map an array reactively (without render)", () => {
+    const arr = ref([1, 2]);
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr.value, value => {
+      return _$createComponent(Foo, {
+        value: value
+      });
+    });
+    const len = computed(() => {
+      return joined().length;
+    });
+    expect(len.value).toBe(4);
+    arr.value.push(3);
+    triggerRef(arr);
+    expect(len.value).toBe(6);
+  });
+  it("can map an array reactively (with render)", () => {
+    let callCount = 0;
+    const arr = ref([1, 2]);
+    function Foo(props) {
+      callCount++;
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr.value, value => {
+      return _$createComponent(Foo, {
+        value: value
+      });
+    });
+    renderTree(joined);
+    expect(callCount).toBe(2);
+    arr.value.push(3);
+    triggerRef(arr);
+    flushJobs();
+    expect(callCount).toBe(3);
+  });
+  it("can map a joiner", () => {
+    const arr = [1, 2];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr, value => _$createComponent(Foo, {
+      value: value
+    }), {
+      joiner: "-"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2
+    `);
+  });
+  it("can map an ender", () => {
+    const arr = [1, 2];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr, value => _$createComponent(Foo, {
+      value: value
+    }), {
+      joiner: "-",
+      ender: ";"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2;
+    `);
+  });
+  it("can map using an iterator", () => {
+    const arr = [1, 2].values();
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = mapJoin(() => arr, value => _$createComponent(Foo, {
+      value: value
+    }), {
+      joiner: "-",
+      ender: ";"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2;
+    `);
+  });
+});
+describe("join", () => {
+  it("can join an array", () => {
+    const arr = [_$createComponent(Foo, {
+      value: 1
+    }), _$createComponent(Foo, {
+      value: 2
+    })];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = join(arr);
+    expect(joined).toRenderTo(`
+      Value: 1
+      Value: 2
+    `);
+  });
+  it("can join an array with a joiner", () => {
+    const arr = [_$createComponent(Foo, {
+      value: 1
+    }), _$createComponent(Foo, {
+      value: 2
+    })];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = join(arr, {
+      joiner: "-"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2
+    `);
+  });
+  it("can join an array with an ender", () => {
+    const arr = [_$createComponent(Foo, {
+      value: 1
+    }), _$createComponent(Foo, {
+      value: 2
+    })];
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = join(arr, {
+      joiner: "-",
+      ender: ";"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2;
+    `);
+  });
+  it("can join using an iterator", () => {
+    const arrIter = [_$createComponent(Foo, {
+      value: 1
+    }), _$createComponent(Foo, {
+      value: 2
+    })].values();
+    function Foo(props) {
+      return ["Value: ", _$memo(() => props.value)];
+    }
+    const joined = join(arrIter, {
+      joiner: "-",
+      ender: ";"
+    });
+    expect(joined).toRenderTo(`
+      Value: 1-Value: 2;
+    `);
+  });
+});
+describe("children", () => {
+  let resolvedChildren;
+  function ResolveChildren(props) {
+    resolvedChildren = children(() => props.children, {
+      preserveFragments: props.preserveFragments
+    })();
+  }
+  it("resolves a single child", () => {
+    renderTree(_$createComponent(ResolveChildren, {
+      children: "1"
+    }));
+    expect(resolvedChildren).toEqual("1");
+  });
+  it("resolves multiple children", () => {
+    renderTree(_$createComponent(ResolveChildren, {
+      get children() {
+        return ["1", "2", "3"];
+      }
+    }));
+    expect(resolvedChildren).toEqual(["1", "2", "3"]);
+  });
+  it("resolves fragments by default", () => {
+    renderTree(_$createComponent(ResolveChildren, {
+      get children() {
+        return [["1"], ["2"], ["3"]];
+      }
+    }));
+    expect(resolvedChildren).toEqual(["1", "2", "3"]);
+  });
+  it("preserves fragments if asked", () => {
+    renderTree(_$createComponent(ResolveChildren, {
+      preserveFragments: true,
+      get children() {
+        return [["1"], ["2"], ["3"]];
+      }
+    }));
+    expect(resolvedChildren).toEqual([["1"], ["2"], ["3"]]);
+  });
+});

package/dist/testing/extend-expect.js

@@ -18,5 +18,4 @@ expect.extend({
       expected
     };
   }
-});
-//# sourceMappingURL=extend-expect.js.map
+});

package/dist/testing/index.js

@@ -1,3 +1,2 @@
 import "./extend-expect.js";
-export * from "./render.js";
-//# sourceMappingURL=index.js.map
+export * from "./render.js";

package/dist/testing/render.js

@@ -19,5 +19,4 @@ export function dedent(str) {
   // Remove the indent from each line
   const dedented = str.split("\n").map(line => line.startsWith(indent) ? line.slice(indent.length) : line).join("\n");
   return dedented;
-}
-//# sourceMappingURL=render.js.map
+}