@alloy-js/core 0.10.0 → 0.12.0

package/dist/test/components/list.test.js

@@ -0,0 +1,86 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { expect, it } from "vitest";
+import { List, printTree, ref, renderTree } from "../../src/index.js";
+import "../../testing/extend-expect.js";
+import { d } from "../../testing/render.js";
+it("creates a list with default options", () => {
+  const template = _$createIntrinsic("group", {
+    get children() {
+      return _$createComponent(List, {
+        get children() {
+          return [["1"], ["2"], ["3"]];
+        }
+      });
+    }
+  });
+  expect(template).toRenderTo(`
+    1
+    2
+    3
+  `);
+});
+it("creates a list with some options", () => {
+  expect(_$createIntrinsic("group", {
+    get children() {
+      return _$createComponent(List, {
+        comma: true,
+        line: true,
+        get children() {
+          return [["1"], ["2"], ["3"]];
+        }
+      });
+    }
+  })).toRenderTo(`1, 2, 3`);
+});
+it("creates a list item for substitutions", () => {
+  expect(_$createIntrinsic("group", {
+    get children() {
+      return _$createComponent(List, {
+        comma: true,
+        line: true,
+        get children() {
+          return [1, 2, 3];
+        }
+      });
+    }
+  })).toRenderTo(`1, 2, 3`);
+});
+it("doesn't create list items for undefined, null, and boolean values", () => {
+  expect(_$createIntrinsic("group", {
+    get children() {
+      return _$createComponent(List, {
+        comma: true,
+        line: true,
+        get children() {
+          return [false, 1, true, 2, null, 3, undefined];
+        }
+      });
+    }
+  })).toRenderTo(`1, 2, 3`);
+});
+it("is useful for statements", () => {
+  function Statement() {
+    return "console.log(true)";
+  }
+  const includeStatement = ref(false);
+  const tree = renderTree(_$createComponent(List, {
+    semicolon: true,
+    hardline: true,
+    ender: true,
+    get children() {
+      return [_$createComponent(Statement, {}), _$memo(() => _$memo(() => !!includeStatement.value)() && _$createComponent(Statement, {})), _$createComponent(Statement, {})];
+    }
+  }));
+  expect(printTree(tree)).toEqual(d`
+    console.log(true);
+    console.log(true);
+
+  `);
+  includeStatement.value = true;
+  expect(printTree(tree)).toEqual(d`
+    console.log(true);
+    console.log(true);
+    console.log(true);
+
+  `);
+});

package/dist/test/components/prose.test.js

@@ -0,0 +1,25 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { Prose } from "../../src/components/Prose.js";
+import "../../testing/extend-expect.js";
+import { d } from "../../testing/render.js";
+describe("Prose", () => {
+  it("formats properly", () => {
+    const template = [_$createComponent(Prose, {
+      children: "This is a long paragraph that should end up being broken into multiple lines."
+    }), _$createIntrinsic("hbr", {}), _$createIntrinsic("hbr", {}), _$createComponent(Prose, {
+      children: "This is another paragraph. There should be a couple breaks in front of it."
+    })];
+    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/dist/test/components/reference-or-content.test.d.ts

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

package/dist/test/components/reference-or-content.test.d.ts.map

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

package/dist/test/components/reference-or-content.test.js

@@ -0,0 +1,149 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { createTap, Declaration, List, Output, ReferenceOrContent, refkey, resolve, Scope, SourceFile, useBinder } from "../../src/index.js";
+import { d, renderToString } from "../../testing/render.js";
+function TestWrapper(props) {
+  const GetBinder = createTap(() => useBinder());
+  function Reference(props) {
+    const result = resolve(props.refkey);
+    return result.value.targetDeclaration.name;
+  }
+  return _$createComponent(Output, {
+    get children() {
+      return _$createComponent(SourceFile, {
+        path: "test.txt",
+        filetype: "txt",
+        reference: Reference,
+        get children() {
+          return [_$createComponent(GetBinder, {}), _$createComponent(Scope, {
+            get children() {
+              return _$createComponent(List, {
+                get children() {
+                  return props.children;
+                }
+              });
+            }
+          })];
+        }
+      });
+    }
+  });
+}
+describe("render the reference name if a declaration exists", () => {
+  it("declaration is before", () => {
+    const rk1 = refkey();
+    const template = _$createComponent(TestWrapper, {
+      get children() {
+        return [_$createComponent(Declaration, {
+          name: "A",
+          refkey: rk1,
+          children: "Declare A"
+        }), _$createComponent(ReferenceOrContent, {
+          refkey: rk1,
+          children: "No Reference A"
+        })];
+      }
+    });
+    expect(renderToString(template)).toEqual(d`
+      Declare A
+      A
+    `);
+  });
+  it("declaration is after", () => {
+    const rk1 = refkey();
+    const template = _$createComponent(TestWrapper, {
+      get children() {
+        return [_$createComponent(ReferenceOrContent, {
+          refkey: rk1,
+          children: "No Reference A"
+        }), _$createComponent(Declaration, {
+          name: "A",
+          refkey: rk1,
+          children: "Declare A"
+        })];
+      }
+    });
+    expect(renderToString(template)).toEqual(d`
+    A
+    Declare A
+  `);
+  });
+});
+it("render content if there is not declaration attached to symbol", () => {
+  const rk1 = refkey();
+  const template = _$createComponent(TestWrapper, {
+    get children() {
+      return _$createComponent(ReferenceOrContent, {
+        refkey: rk1,
+        children: "No Reference A"
+      });
+    }
+  });
+  expect(renderToString(template)).toEqual(d`
+    No Reference A
+  `);
+});
+it("mixed", () => {
+  const rk1 = refkey();
+  const rk2 = refkey();
+  const template = _$createComponent(TestWrapper, {
+    get children() {
+      return [_$createComponent(Declaration, {
+        name: "A",
+        refkey: rk1,
+        children: "Declare A"
+      }), _$createComponent(ReferenceOrContent, {
+        refkey: rk1,
+        children: "No Reference A"
+      }), _$createComponent(ReferenceOrContent, {
+        refkey: rk2,
+        children: "No Reference B"
+      })];
+    }
+  });
+  expect(renderToString(template)).toEqual(d`
+    Declare A
+    A
+    No Reference B
+  `);
+});
+it("resolve ref via source file reference", () => {
+  const rk1 = refkey();
+  const GetBinder = createTap(() => useBinder());
+  const Reference = vi.fn(props => {
+    const result = resolve(props.refkey);
+    return `ViaRef.${result.value.targetDeclaration.name}`;
+  });
+  const template = _$createComponent(Output, {
+    get children() {
+      return _$createComponent(SourceFile, {
+        path: "test.txt",
+        filetype: "txt",
+        reference: Reference,
+        get children() {
+          return [_$createComponent(GetBinder, {}), _$createComponent(Scope, {
+            get children() {
+              return _$createComponent(List, {
+                get children() {
+                  return [_$createComponent(Declaration, {
+                    name: "A",
+                    refkey: rk1,
+                    children: "Declare A"
+                  }), _$createComponent(ReferenceOrContent, {
+                    refkey: rk1,
+                    children: "No Reference A"
+                  })];
+                }
+              });
+            }
+          })];
+        }
+      });
+    }
+  });
+  expect(renderToString(template)).toEqual(d`
+    Declare A
+    ViaRef.A
+  `);
+  expect(Reference).toHaveBeenCalledTimes(1);
+});

package/dist/test/components/slot.test.js

@@ -0,0 +1,134 @@
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { it } from "vitest";
+import { Output } from "../../src/components/Output.js";
+import { SourceFile } from "../../src/components/SourceFile.js";
+import { Declaration, Name, refkey, Scope, useBinder } from "../../src/index.js";
+import { render } from "../../src/render.js";
+import { defineSlot, rename, replace } from "../../src/slot.js";
+import "../../testing/extend-expect.js";
+it("works with string keys", () => {
+  const FunctionSlot = defineSlot(query => query.name);
+  function MyFunctionComponent(props) {
+    const FunctionSlotInstance = FunctionSlot.create(props.name, {
+      ...props,
+      additionalProp: "hi"
+    }, ["function ", _$memo(() => props.name), "() ", "{", "console.log(\"hello world\");", "}"]);
+    return _$createComponent(FunctionSlotInstance, {});
+  }
+
+  // extension.tsx
+  replace(FunctionSlot.find({
+    name: "foo"
+  }), props => {
+    return ["// original", _$memo(() => props.original)];
+  });
+  const tree = render(_$createComponent(Output, {
+    get children() {
+      return _$createComponent(SourceFile, {
+        path: "test.ts",
+        filetype: "ts",
+        get children() {
+          return _$createComponent(MyFunctionComponent, {
+            name: "foo"
+          });
+        }
+      });
+    }
+  }));
+  console.log(tree.contents[0].contents);
+});
+it("works with symbols", () => {
+  const FunctionSlot = defineSlot(query => {
+    const binder = useBinder();
+    return binder.resolveFQN(query.fqn);
+  });
+  function MyFunctionComponent(props) {
+    const binder = useBinder();
+    const sym = binder.createSymbol({
+      name: props.name,
+      refkey: refkey()
+    });
+    const FunctionSlotInstance = FunctionSlot.create(sym, {
+      ...props,
+      additionalProp: "hi"
+    }, _$createComponent(Declaration, {
+      symbol: sym,
+      get children() {
+        return ["function ", _$createComponent(Name, {}), "() ", "{", "console.log(\"hello world\");", "}"];
+      }
+    }));
+    return _$createComponent(FunctionSlotInstance, {});
+  }
+
+  // extension.tsx
+  replace(FunctionSlot.find({
+    fqn: "foo.bar"
+  }), props => {
+    return ["// original", _$memo(() => props.original)];
+  });
+  const tree = render(_$createComponent(Output, {
+    get children() {
+      return _$createComponent(SourceFile, {
+        path: "test.ts",
+        filetype: "ts",
+        get children() {
+          return _$createComponent(Scope, {
+            name: "foo",
+            get children() {
+              return _$createComponent(MyFunctionComponent, {
+                name: "bar"
+              });
+            }
+          });
+        }
+      });
+    }
+  }));
+  console.log(tree.contents[0].contents);
+});
+it("can rename", () => {
+  const FunctionSlot = defineSlot(query => {
+    const binder = useBinder();
+    return binder.resolveFQN(query.fqn);
+  });
+  function MyFunctionComponent(props) {
+    const binder = useBinder();
+    const sym = binder.createSymbol({
+      name: props.name,
+      refkey: refkey()
+    });
+    const FunctionSlotInstance = FunctionSlot.create(sym, {
+      ...props,
+      additionalProp: "hi"
+    }, _$createComponent(Declaration, {
+      symbol: sym,
+      get children() {
+        return ["function ", _$createComponent(Name, {}), "() ", "{", "console.log(\"hello world\");", "}"];
+      }
+    }));
+    return _$createComponent(FunctionSlotInstance, {});
+  }
+  rename(() => {
+    const binder = useBinder();
+    return binder.resolveFQN("foo.bar");
+  }, "bazxxx");
+  const tree = render(_$createComponent(Output, {
+    get children() {
+      return _$createComponent(SourceFile, {
+        path: "test.ts",
+        filetype: "ts",
+        get children() {
+          return _$createComponent(Scope, {
+            name: "foo",
+            get children() {
+              return _$createComponent(MyFunctionComponent, {
+                name: "bar"
+              });
+            }
+          });
+        }
+      });
+    }
+  }));
+  console.log(tree.contents[0].contents);
+});

package/dist/test/components/source-file.test.js

@@ -0,0 +1,64 @@
+import { createComponent as _$createComponent, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { computed, Output, render, renderTree, SourceFile, useContext } from "@alloy-js/core";
+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;
+  function Test() {
+    context = useContext(SourceDirectoryContext);
+  }
+  const _ = renderTree(_$createComponent(Output, {
+    get children() {
+      return [_$createComponent(Test, {}), _$createComponent(SourceFile, {
+        path: "hi.txt",
+        filetype: "text",
+        children: "hello!"
+      })];
+    }
+  }));
+  expect(context.contents.length).toEqual(1);
+});
+it("has reactive context", () => {
+  function TrackContents() {
+    const sdContext = useContext(SourceDirectoryContext);
+    const allFiles = computed(() => {
+      return sdContext.contents.map(v => v.path).join(" ");
+    });
+    return _$createComponent(SourceFile, {
+      path: "contents.txt",
+      filetype: "text",
+      get children() {
+        return allFiles.value;
+      }
+    });
+  }
+  const tree = render(_$createComponent(Output, {
+    get children() {
+      return [_$createComponent(SourceFile, {
+        path: "hi.txt",
+        filetype: "text",
+        children: "hello!"
+      }), _$createComponent(TrackContents, {})];
+    }
+  }));
+  expect(tree.contents[1].contents).toEqual("hi.txt contents.txt");
+});
+it("Includes header", () => {
+  const header = ["# This is a header"];
+  const tree = render(_$createComponent(Output, {
+    get children() {
+      return _$createComponent(SourceFile, {
+        path: "hi.txt",
+        filetype: "text",
+        header: header,
+        children: "hello!"
+      });
+    }
+  }));
+  expect(tree.contents[0].contents).toEqual(d`
+    # This is a header
+    hello!
+    `);
+});

package/dist/test/components/wrap.test.js

@@ -0,0 +1,35 @@
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { ref } from "@vue/reactivity";
+import { expect, it } from "vitest";
+import { Wrap } from "../../src/components/Wrap.js";
+import { printTree, renderTree } from "../../src/render.js";
+import "../../testing/extend-expect.js";
+function Wrapper(props) {
+  return ["[", _$memo(() => props.children), "]"];
+}
+it("conditionally wraps", () => {
+  const template = [_$createComponent(Wrap, {
+    when: true,
+    "with": Wrapper,
+    children: "testing"
+  }), _$createComponent(Wrap, {
+    when: false,
+    "with": Wrapper,
+    children: "testing"
+  })];
+  expect(template).toRenderTo(`[testing]testing`);
+});
+it("works reactively", () => {
+  const doWrap = ref(false);
+  const template = [_$createComponent(Wrap, {
+    get when() {
+      return doWrap.value;
+    },
+    "with": Wrapper,
+    children: "testing"
+  })];
+  const tree = renderTree(template);
+  expect(printTree(tree)).toEqual(`testing`);
+  doWrap.value = true;
+  expect(printTree(tree)).toEqual(`testing`);
+});