@fluid-topics/public-api 1.0.56 → 1.0.58

package/test-browser/helpers/GenAIChunkReader.test.ts

@@ -0,0 +1,54 @@
+import { expect } from "@open-wc/testing"
+import { GenAIChunkReader } from "../../src/helpers/GenAIChunkReader"
+
+class FakeStream implements ReadableStreamDefaultReader<Uint8Array> {
+    readonly closed: Promise<undefined>
+    readonly encoder = new TextEncoder()
+
+    constructor(readonly chunks: string[]) {
+    }
+
+    cancel(reason?: any): Promise<void> {
+        return Promise.resolve(undefined)
+    }
+
+    read() {
+        if (this.chunks.length === 0) {
+            return Promise.resolve({ done: true, value: undefined })
+        }
+        const chunk = this.chunks.shift()
+        let value: Uint8Array = this.encoder.encode(chunk)
+        return Promise.resolve({ done: false, value })
+    }
+
+    releaseLock(): void {
+    }
+
+}
+
+describe(GenAIChunkReader.name, () => {
+    it("should wait for complete chunks", async () => {
+        const stream = new FakeStream([
+            `data:{`,
+            `"foo`,
+            `":"bar"}\n`,
+            `data:{"foo":"quz"}\n`
+        ])
+        const generator = new GenAIChunkReader(stream).read()
+
+        expect((await generator.next()).value).to.deep.equal({ "foo": "bar" })
+        expect((await generator.next()).value).to.deep.equal({ "foo": "quz" })
+        expect((await generator.next()).done).to.be.true
+    })
+
+    it("should ignore non-data chunks", async () => {
+        const stream = new FakeStream([
+            `patate:{"foo":"bar"}\n`,
+            `data:{"foo":"quz"}\n`
+        ])
+        const generator = new GenAIChunkReader(stream).read()
+
+        expect((await generator.next()).value).to.deep.equal({ "foo": "quz" })
+        expect((await generator.next()).done).to.be.true
+    })
+})

package/vite-plugin.mjs

@@ -0,0 +1,95 @@
+import http from "node:http"
+import {existsSync} from "node:fs"
+import {createServer} from "vite"
+
+const callWithFileNames = (callback) => ({
+    name: "file-name",
+    transform(src, id) {
+        callback(id)
+    },
+})
+
+const markExternal = (options) => ({
+    name: "mark-external",
+    resolveId(path) {
+        if (!options.includes(path)) {
+            return
+        }
+
+        return {
+            id: path,
+            external: true
+        }
+    },
+})
+
+const get = url => new Promise((resolve, reject) => {
+    const request = http.get(url, (response) => {
+        const buffers = []
+        let bufferLen = 0
+
+        response.on("data", chunk => {
+            bufferLen += chunk.length
+            buffers.push(chunk)
+        })
+
+        response.on("end", () => resolve({
+            body: Buffer.concat(buffers, bufferLen),
+            headers: response.headers,
+            status: response.statusCode,
+        }))
+    })
+
+    request.on("error", (err) => reject(err))
+})
+
+const proxy = (url) => async ctx => {
+    const {body, headers, status} = await get(url + ctx.originalUrl)
+    ctx.set(headers)
+    ctx.body = body
+    ctx.status = status
+}
+
+export const vitePlugin = (conf) => {
+    let viteServer
+
+    return {
+        name: "vite-plugin",
+
+        async serverStart({app, fileWatcher}) {
+            const plugins = [
+                callWithFileNames(id => {
+                    const file = id.split("?")[0]
+                    if (!file.startsWith("\0") && existsSync(file)) {
+                        fileWatcher.add(id)
+                    }
+                }),
+                markExternal([
+                    /* @web/test-runner-commands needs to establish a web-socket
+                     * connection. It expects a file to be served from the
+                     * @web/dev-server. So it should be ignored by Vite */
+                    "/__web-dev-server__web-socket.js",
+                ]),
+            ]
+
+            viteServer = await createServer({
+                clearScreen: false,
+                plugins,
+                /* Disable hmr in favor of the @web/test-runner to take care of
+                 * restarts. */
+                server: {hmr: false},
+                ...conf
+            })
+            await viteServer.listen()
+
+            const vitePort = viteServer.config.server.port
+            const viteProtocol = viteServer.config.server.https ? "https" : "http"
+
+            app.use(proxy(`${viteProtocol}://localhost:${vitePort}`))
+        },
+
+        async serverStop() {
+            return viteServer.close()
+        },
+    }
+}

package/web-test-runner.config.mjs

@@ -0,0 +1,58 @@
+import {playwrightLauncher} from '@web/test-runner-playwright';
+import {defaultReporter} from "@web/test-runner";
+import {junitReporter} from "@web/test-runner-junit-reporter";
+import {vitePlugin} from "./vite-plugin.mjs";
+
+const ignoredLogs = [
+    "[vite] connecting...",
+    "[vite] connected.",
+    "Lit is in dev mode.",
+    "Multiple versions of Lit loaded.",
+    "Fluid Topics public API was not found.",
+    "scheduled an update (generally because a property was set) after an update completed",
+]
+
+export default {
+    rootDir: '.',
+    files: ['./test-browser/**/*.test.ts'],
+    nodeResolve: true,
+    preserveSymlinks: true,
+    browsers: [
+        playwrightLauncher({product: 'chromium'}),
+    ],
+    reporters: [
+        defaultReporter({reportTestResults: true, reportTestProgress: true}),
+        junitReporter({
+            outputPath: './build/test-results/web-components.xml',
+            reportLogs: true,
+        }),
+    ],
+    plugins: [
+        vitePlugin({
+            optimizeDeps: {
+                disabled: true
+            }
+        }),
+        {
+            name: "cross-fetch-plugin",
+            async serve(context) {
+                if (context.path.includes("cross-fetch")) {
+                    return `export default {}`;
+                }
+            }
+        },
+    ],
+    filterBrowserLogs: (log) => !(typeof log.args[0] === "string" && ignoredLogs.some(l => log.args[0].includes(l))),
+    testRunnerHtml: (testRunnerImport) => `
+        <html>
+        <body>
+            <script type="module">
+            window.process = { env: { NODE_ENV: 'test' } };
+            </script>
+            <script type="module">
+                import '${testRunnerImport}';
+            </script>
+        </body>
+        </html>
+    `,
+};