@microsoft/fast-test-harness 0.1.0 → 0.2.0

package/dist/dts/fixtures/ssr-fixture.pw.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ssr-fixture.pw.spec.d.ts.map

package/dist/dts/fixtures/ssr-fixture.pw.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssr-fixture.pw.spec.d.ts","sourceRoot":"","sources":["../../../src/fixtures/ssr-fixture.pw.spec.ts"],"names":[],"mappings":""}

package/dist/dts/ssr/render.test.d.ts

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

package/dist/dts/ssr/render.test.d.ts.map

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

package/dist/esm/build/dom-shim.test.js

@@ -1,202 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-// Each test needs a clean globalThis, so we tear down the shim between tests.
-function teardownShim() {
-    for (const key of [
-        "Node",
-        "Element",
-        "HTMLElement",
-        "Document",
-        "CustomEvent",
-        "CSSStyleSheet",
-        "ShadowRoot",
-        "CustomElementRegistry",
-        "MutationObserver",
-        "MediaQueryList",
-        "matchMedia",
-        "document",
-        "customElements",
-        "window",
-        "CSS",
-    ]) {
-        delete globalThis[key];
-    }
-}
-test.describe("installDomShim", () => {
-    test.beforeEach(() => {
-        teardownShim();
-    });
-    async function loadShim() {
-        // Dynamic import so each test gets a fresh evaluation context
-        // after globalThis is cleaned.
-        const { installDomShim } = await import("@microsoft/fast-test-harness/build/dom-shim.js");
-        installDomShim();
-    }
-    test("should assign globals on first call", async () => {
-        await loadShim();
-        assert.ok(globalThis.window !== undefined);
-        assert.ok(globalThis.document !== undefined);
-        assert.ok(globalThis.customElements !== undefined);
-        assert.ok(globalThis.Node !== undefined);
-        assert.ok(globalThis.Element !== undefined);
-        assert.ok(globalThis.HTMLElement !== undefined);
-        assert.ok(globalThis.CSSStyleSheet !== undefined);
-        assert.ok(globalThis.MutationObserver !== undefined);
-        assert.ok(globalThis.matchMedia !== undefined);
-    });
-    test("should be idempotent when window is already defined", async () => {
-        const sentinel = { __sentinel: true };
-        globalThis.window = sentinel;
-        await loadShim();
-        assert.strictEqual(globalThis.window, sentinel);
-        assert.strictEqual(globalThis.document, undefined);
-    });
-    test("should set window to globalThis", async () => {
-        await loadShim();
-        assert.strictEqual(globalThis.window, globalThis);
-    });
-    test("should provide CSS.supports that returns true", async () => {
-        await loadShim();
-        assert.strictEqual(globalThis.CSS.supports("display", "flex"), true);
-    });
-    test("should not overwrite an existing CSS global", async () => {
-        const existing = { supports: () => false };
-        globalThis.CSS = existing;
-        await loadShim();
-        assert.strictEqual(globalThis.CSS, existing);
-    });
-});
-test.describe("ShimHTMLElement", () => {
-    test.beforeEach(async () => {
-        teardownShim();
-        const { installDomShim } = await import("@microsoft/fast-test-harness/build/dom-shim.js");
-        installDomShim();
-    });
-    test("should support setAttribute / getAttribute / hasAttribute", () => {
-        const el = new globalThis.HTMLElement();
-        assert.strictEqual(el.hasAttribute("id"), false);
-        assert.strictEqual(el.getAttribute("id"), null);
-        el.setAttribute("id", "test");
-        assert.strictEqual(el.hasAttribute("id"), true);
-        assert.strictEqual(el.getAttribute("id"), "test");
-    });
-    test("should support removeAttribute", () => {
-        const el = new globalThis.HTMLElement();
-        el.setAttribute("class", "foo");
-        assert.strictEqual(el.hasAttribute("class"), true);
-        el.removeAttribute("class");
-        assert.strictEqual(el.hasAttribute("class"), false);
-        assert.strictEqual(el.getAttribute("class"), null);
-    });
-    test("should return attributes as an array of {name, value}", () => {
-        const el = new globalThis.HTMLElement();
-        el.setAttribute("role", "button");
-        el.setAttribute("aria-label", "Close");
-        const attrs = el.attributes;
-        assert.strictEqual(attrs.length, 2);
-        assert.deepStrictEqual(attrs.map((a) => a.name).sort(), [
-            "aria-label",
-            "role",
-        ]);
-    });
-    test("should support attachShadow with open mode", () => {
-        const el = new globalThis.HTMLElement();
-        const sr = el.attachShadow({ mode: "open" });
-        assert.ok(sr);
-        assert.strictEqual(sr.host, el);
-        assert.strictEqual(el.shadowRoot, sr);
-    });
-    test("should not expose shadowRoot for closed mode", () => {
-        const el = new globalThis.HTMLElement();
-        el.attachShadow({ mode: "closed" });
-        assert.strictEqual(el.shadowRoot, null);
-    });
-    test("should provide a classList stub", () => {
-        const el = new globalThis.HTMLElement();
-        const cl = el.classList;
-        assert.strictEqual(cl.contains("foo"), false);
-        // Should not throw
-        cl.add("foo");
-        cl.remove("foo");
-        cl.toggle("foo");
-    });
-});
-test.describe("ShimCSSStyleSheet", () => {
-    test.beforeEach(async () => {
-        teardownShim();
-        const { installDomShim } = await import("@microsoft/fast-test-harness/build/dom-shim.js");
-        installDomShim();
-    });
-    test("should support insertRule", () => {
-        const sheet = new globalThis.CSSStyleSheet();
-        const idx = sheet.insertRule(".foo { color: red }", 0);
-        assert.strictEqual(idx, 0);
-        assert.strictEqual(sheet.cssRules.length, 1);
-        assert.strictEqual(sheet.cssRules[0].selectorText, ".foo ");
-    });
-});
-test.describe("ShimCustomElementRegistry", () => {
-    test.beforeEach(async () => {
-        teardownShim();
-        const { installDomShim } = await import("@microsoft/fast-test-harness/build/dom-shim.js");
-        installDomShim();
-    });
-    test("should support define and get", () => {
-        class MyEl {
-        }
-        globalThis.customElements.define("my-el", MyEl);
-        assert.strictEqual(globalThis.customElements.get("my-el"), MyEl);
-    });
-    test("should return undefined for unknown elements", () => {
-        assert.strictEqual(globalThis.customElements.get("unknown-el"), undefined);
-    });
-    test("should resolve whenDefined immediately", async () => {
-        const result = await globalThis.customElements.whenDefined("any-el");
-        assert.strictEqual(result, undefined);
-    });
-});
-test.describe("ShimDocument", () => {
-    test.beforeEach(async () => {
-        teardownShim();
-        const { installDomShim } = await import("@microsoft/fast-test-harness/build/dom-shim.js");
-        installDomShim();
-    });
-    test("should create elements via createElement", () => {
-        const el = globalThis.document.createElement("div");
-        assert.ok(el);
-        assert.strictEqual(typeof el.setAttribute, "function");
-    });
-    test("should support adoptedStyleSheets", () => {
-        assert.ok(Array.isArray(globalThis.document.adoptedStyleSheets));
-    });
-});
-test.describe("ShimCustomEvent", () => {
-    test.beforeEach(async () => {
-        teardownShim();
-        const { installDomShim } = await import("@microsoft/fast-test-harness/build/dom-shim.js");
-        installDomShim();
-    });
-    test("should carry detail", () => {
-        const evt = new globalThis.CustomEvent("test", { detail: 42 });
-        assert.strictEqual(evt.detail, 42);
-        assert.strictEqual(evt.type, "test");
-    });
-    test("should default detail to null", () => {
-        const evt = new globalThis.CustomEvent("test");
-        assert.strictEqual(evt.detail, null);
-    });
-});
-test.describe("matchMedia", () => {
-    test.beforeEach(async () => {
-        teardownShim();
-        const { installDomShim } = await import("@microsoft/fast-test-harness/build/dom-shim.js");
-        installDomShim();
-    });
-    test("should return a MediaQueryList with matches = false", () => {
-        const mql = globalThis.matchMedia("(prefers-color-scheme: dark)");
-        assert.strictEqual(mql.matches, false);
-        // Should not throw
-        mql.addEventListener("change", () => { });
-        mql.removeEventListener("change", () => { });
-    });
-});

package/dist/esm/build/generate-stylesheets.test.js

@@ -1,74 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import { generateStylesheets } from "@microsoft/fast-test-harness/build/generate-stylesheets.js";
-test.describe("generateStylesheets", () => {
-    let tempDir;
-    test.beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), "fast-styles-"));
-    });
-    test.afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    test("should extract CSS from a styles module", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        // Write a fake styles module that exports an ElementStyles-like object.
-        await writeFile(join(distDir, "button.styles.js"), `export const styles = { styles: [":host { display: block; }", "span { color: red; }"] };`);
-        await generateStylesheets({ cwd: tempDir });
-        const css = await readFile(join(distDir, "button.styles.css"), "utf8");
-        assert.ok(css.includes(":host { display: block; }"));
-        assert.ok(css.includes("span { color: red; }"));
-    });
-    test("should write to outDir when specified", async () => {
-        const distDir = join(tempDir, "dist");
-        const outDir = join(tempDir, "out");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "card.styles.js"), `export const styles = { styles: [".card { padding: 8px; }"] };`);
-        await generateStylesheets({ cwd: tempDir, outDir: "out" });
-        const css = await readFile(join(outDir, "card.styles.css"), "utf8");
-        assert.ok(css.includes(".card { padding: 8px; }"));
-    });
-    test("should apply a format function", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "link.styles.js"), `export const styles = { styles: ["a { color: blue; }"] };`);
-        await generateStylesheets({
-            cwd: tempDir,
-            format: css => `/* formatted */\n${css}`,
-        });
-        const css = await readFile(join(distDir, "link.styles.css"), "utf8");
-        assert.ok(css.startsWith("/* formatted */"));
-    });
-    test("should flatten nested styles arrays", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "nested.styles.js"), `export const styles = {
-                styles: [
-                    { styles: [":host { display: flex; }", "div { margin: 0; }"] },
-                    "span { font-size: 14px; }"
-                ]
-            };`);
-        await generateStylesheets({ cwd: tempDir });
-        const css = await readFile(join(distDir, "nested.styles.css"), "utf8");
-        assert.ok(css.includes(":host { display: flex; }"));
-        assert.ok(css.includes("div { margin: 0; }"));
-        assert.ok(css.includes("span { font-size: 14px; }"));
-    });
-    test("should skip modules without a styles export", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "empty.styles.js"), `export const template = "<div></div>";`);
-        await generateStylesheets({ cwd: tempDir });
-        // Should not create a CSS file
-        try {
-            await readFile(join(distDir, "empty.styles.css"), "utf8");
-            assert.fail("Should not have created a CSS file");
-        }
-        catch (err) {
-            assert.strictEqual(err.code, "ENOENT");
-        }
-    });
-});

package/dist/esm/build/generate-templates.test.js

@@ -1,231 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import { installDomShim } from "@microsoft/fast-test-harness/build/dom-shim.js";
-import { convertTemplate, generateFTemplates, } from "@microsoft/fast-test-harness/build/generate-templates.js";
-import { generateWebuiTemplates } from "@microsoft/fast-test-harness/build/generate-webui-templates.js";
-test.describe("convertTemplate", async () => {
-    // Install the DOM shim before any tests — convertTemplate needs fast-html
-    // syntax constants which require a DOM environment, and FAST Element needs
-    // basic DOM globals to initialize.
-    installDomShim();
-    // Dynamic import after the DOM shim is installed so FAST Element can
-    // access `document`, `CSSStyleSheet`, etc.
-    const { html, ref, slotted, children } = await import("@microsoft/fast-element");
-    test("should wrap a static template in f-template tags", () => {
-        const template = html `<template><div>hello</div></template>`;
-        const result = convertTemplate(template, "fast-test");
-        assert.ok(result);
-        assert.ok(result.includes('<f-template name="fast-test"'));
-        assert.ok(result.includes("shadowrootmode"));
-        assert.ok(result.includes("<div>hello</div>"));
-        assert.ok(result.includes("{{styles}}"));
-    });
-    test("should return null-safe for empty factories", () => {
-        const template = html `<template><span></span></template>`;
-        const result = convertTemplate(template, "fast-empty");
-        assert.ok(result);
-        assert.ok(result.includes("<span></span>"));
-    });
-    test("should inject {{styles}} after the opening template tag", () => {
-        const template = html `<template><p>content</p></template>`;
-        const result = convertTemplate(template, "fast-styles");
-        assert.ok(result);
-        const templateIdx = result.indexOf("<template>");
-        const stylesIdx = result.indexOf("{{styles}}");
-        assert.ok(stylesIdx > templateIdx, "{{styles}} should appear after <template>");
-    });
-    test("should convert RefDirective factories to f-ref attributes", () => {
-        const template = html `<template><div ${ref("myRef")}></div></template>`;
-        const result = convertTemplate(template, "fast-ref");
-        assert.ok(result);
-        assert.ok(result.includes('f-ref="{myRef}"'), `got: ${result}`);
-    });
-    test("should convert SlottedDirective factories to f-slotted attributes", () => {
-        const template = html `<template><slot ${slotted("slottedItems")}></slot></template>`;
-        const result = convertTemplate(template, "fast-slotted");
-        assert.ok(result);
-        assert.ok(result.includes("f-slotted="), `got: ${result}`);
-        assert.ok(result.includes("slottedItems"), `got: ${result}`);
-    });
-    test("should convert value bindings to {{expression}}", () => {
-        const template = html `<template><span>${x => x.label}</span></template>`;
-        const result = convertTemplate(template, "fast-binding");
-        assert.ok(result);
-        assert.ok(result.includes("{{label}}"), `got: ${result}`);
-    });
-    test("should convert boolean bindings to ?attr expressions", () => {
-        const template = html `<template><button ?disabled="${x => x.disabled}"></button></template>`;
-        const result = convertTemplate(template, "fast-bool");
-        assert.ok(result);
-        assert.ok(result.includes('?disabled="{{disabled}}"'), `got: ${result}`);
-    });
-    test("should inline static sub-templates", () => {
-        const template = html `<template><div>${() => "<svg>icon</svg>"}</div></template>`;
-        const result = convertTemplate(template, "fast-inline");
-        assert.ok(result);
-        assert.ok(result.includes("<svg>icon</svg>"), `got: ${result}`);
-    });
-    test("should convert ChildrenDirective factories to f-children attributes", () => {
-        const template = html `<template><div ${children("childItems")}></div></template>`;
-        const result = convertTemplate(template, "fast-children");
-        assert.ok(result);
-        assert.ok(result.includes("f-children="), `got: ${result}`);
-        assert.ok(result.includes("childItems"), `got: ${result}`);
-    });
-    test("should convert event bindings to @event expressions", () => {
-        const template = html `<template><button @click="${(x, c) => x.handleClick(c.event)}"></button></template>`;
-        const result = convertTemplate(template, "fast-event");
-        assert.ok(result);
-        assert.ok(result.includes("@click="), `got: ${result}`);
-        assert.ok(result.includes("handleClick"), `got: ${result}`);
-    });
-    test("should convert property bindings to :prop expressions", () => {
-        const template = html `<template><input :value="${x => x.currentValue}" /></template>`;
-        const result = convertTemplate(template, "fast-prop");
-        assert.ok(result);
-        assert.ok(result.includes(":value="), `got: ${result}`);
-        assert.ok(result.includes("currentValue"), `got: ${result}`);
-    });
-    test("should handle multiple factories in a single template", () => {
-        const template = html `<template><span>${x => x.label}</span><button ?disabled="${x => x.disabled}"></button></template>`;
-        const result = convertTemplate(template, "fast-multi");
-        assert.ok(result);
-        assert.ok(result.includes("{{label}}"), `got: ${result}`);
-        assert.ok(result.includes('?disabled="{{disabled}}"'), `got: ${result}`);
-    });
-    test("should inline a static sub-template ViewTemplate", () => {
-        const icon = html `<svg>icon</svg>`;
-        const template = html `<template><div>${() => icon}</div></template>`;
-        const result = convertTemplate(template, "fast-sub");
-        assert.ok(result);
-        assert.ok(result.includes("<svg>icon</svg>"), `got: ${result}`);
-    });
-});
-test.describe("generateFTemplates", () => {
-    let tempDir;
-    test.beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), "fast-ftemplates-"));
-    });
-    test.afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    test("should generate an f-template HTML file from a template module", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "badge.template.js"), `export const template = {
-                html: "<template><slot></slot></template>",
-                factories: {}
-            };`);
-        await generateFTemplates({ cwd: tempDir, tagPrefix: "mai" });
-        const html = await readFile(join(distDir, "badge.template.html"), "utf8");
-        assert.ok(html.includes('<f-template name="mai-badge"'));
-        assert.ok(html.includes("<slot></slot>"));
-        assert.ok(html.includes("{{styles}}"));
-    });
-    test("should write to outDir when specified", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "card.template.js"), `export const template = {
-                html: "<template><div>card</div></template>",
-                factories: {}
-            };`);
-        await generateFTemplates({ cwd: tempDir, outDir: "out", tagPrefix: "fast" });
-        const html = await readFile(join(tempDir, "out", "card.template.html"), "utf8");
-        assert.ok(html.includes('<f-template name="fast-card"'));
-    });
-    test("should skip modules without a template export", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "empty.template.js"), `export const styles = ":host {}";`);
-        await generateFTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        try {
-            await readFile(join(distDir, "empty.template.html"), "utf8");
-            assert.fail("Should not have created an HTML file");
-        }
-        catch (err) {
-            assert.strictEqual(err.code, "ENOENT");
-        }
-    });
-    test("should apply a format function", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "text.template.js"), `export const template = {
-                html: "<template><span>text</span></template>",
-                factories: {}
-            };`);
-        await generateFTemplates({
-            cwd: tempDir,
-            tagPrefix: "fast",
-            format: html => `<!-- formatted -->\n${html}`,
-        });
-        const html = await readFile(join(distDir, "text.template.html"), "utf8");
-        assert.ok(html.startsWith("<!-- formatted -->"));
-    });
-});
-test.describe("generateWebuiTemplates", () => {
-    let tempDir;
-    test.beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), "fast-webui-"));
-    });
-    test.afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    test("should generate a webui template without f-template wrapper", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "badge.template.js"), `export const template = {
-                html: "<template><slot></slot></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "mai" });
-        const html = await readFile(join(distDir, "badge.template-webui.html"), "utf8");
-        assert.ok(html.includes('<template shadowrootmode="open">'));
-        assert.ok(html.includes("<slot></slot>"));
-        assert.ok(!html.includes("<f-template"), "should not have f-template wrapper");
-        assert.ok(!html.includes("{{styles}}"), "should not have styles marker");
-    });
-    test("should write to outDir when specified", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "card.template.js"), `export const template = {
-                html: "<template><div>card</div></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({
-            cwd: tempDir,
-            outDir: "out",
-            tagPrefix: "fast",
-        });
-        const html = await readFile(join(tempDir, "out", "card.template-webui.html"), "utf8");
-        assert.ok(html.includes('<template shadowrootmode="open">'));
-    });
-    test("should add shadowrootdelegatesfocus from definition-async", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "input.template.js"), `export const template = {
-                html: "<template><input /></template>",
-                factories: {}
-            };`);
-        await writeFile(join(distDir, "input.definition-async.js"), `export const definition = {
-                name: "fast-input",
-                shadowOptions: { delegatesFocus: true },
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        const html = await readFile(join(distDir, "input.template-webui.html"), "utf8");
-        assert.ok(html.includes("shadowrootdelegatesfocus"), `should include delegatesFocus, got: ${html}`);
-    });
-    test("should not add shadowrootdelegatesfocus when absent", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "div.template.js"), `export const template = {
-                html: "<template><div>hello</div></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        const html = await readFile(join(distDir, "div.template-webui.html"), "utf8");
-        assert.ok(!html.includes("shadowrootdelegatesfocus"));
-    });
-});