@tstdl/base 0.93.181 → 0.93.183

package/pdf/tests/utils.test.js

@@ -1,187 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { describe, expect, it } from 'vitest';
-import { TemporaryFile } from '../../file/server/temporary-file.js';
-import { spawnCommand } from '../../process/spawn.js';
-import { extractPdfPages, getPdfPageCount, mergePdfs, overlayPdfs, pdfToImage } from '../utils.js';
-describe('pdf utils', () => {
-    async function createPdf(pages) {
-        const file = TemporaryFile.create('.pdf');
-        const source = Array.from({ length: pages }, (_, i) => `Page ${i + 1}`).join('\n#pagebreak()\n');
-        const process = await spawnCommand('typst', ['compile', '-', file.path]);
-        await process.write(source);
-        await process.wait();
-        return file;
-    }
-    it('getPdfPageCount should return correct page count', async () => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const pdf = __addDisposableResource(env_1, await createPdf(5), true);
-            const count = await getPdfPageCount(pdf.path);
-            expect(count).toBe(5);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
-        }
-    });
-    it('extractPdfPages should extract specific pages', async () => {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const pdf = __addDisposableResource(env_2, await createPdf(10), true);
-            const extracted = __addDisposableResource(env_2, await extractPdfPages(pdf.path, [1, { from: 3, to: 5 }]), true);
-            const count = await getPdfPageCount(extracted.path);
-            expect(count).toBe(4); // 1 + (5-3+1) = 4
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            const result_2 = __disposeResources(env_2);
-            if (result_2)
-                await result_2;
-        }
-    });
-    it('mergePdfs should handle different input types and page ranges', async () => {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            const pdf1 = __addDisposableResource(env_3, await createPdf(2), true);
-            const pdf2 = __addDisposableResource(env_3, await createPdf(3), true);
-            const pdf2Bytes = await pdf1.read();
-            // Test with path, Uint8Array, and page range object
-            const merged = __addDisposableResource(env_3, await mergePdfs([
-                pdf1.path,
-                pdf2Bytes,
-                { input: pdf2.path, pages: [1, { from: 2, to: 3 }] },
-            ]), true);
-            const count = await getPdfPageCount(merged.path);
-            expect(count).toBe(2 + 2 + 3); // 2 (path) + 2 (bytes) + 3 (page range)
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            const result_3 = __disposeResources(env_3);
-            if (result_3)
-                await result_3;
-        }
-    });
-    it('pdfToImage should work with binary inputs', async () => {
-        const env_4 = { stack: [], error: void 0, hasError: false };
-        try {
-            const pdf = __addDisposableResource(env_4, await createPdf(1), true);
-            const pdfBytes = await pdf.read();
-            // pdftocairo fails in some environments if no fonts are available,
-            // but here we just want to test the branching logic of writing bytes
-            const result = await pdfToImage(pdfBytes, 1, 100, 'png');
-            expect(result).toBeInstanceOf(Uint8Array);
-        }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
-        }
-        finally {
-            const result_4 = __disposeResources(env_4);
-            if (result_4)
-                await result_4;
-        }
-    });
-    it('overlayPdfs should overlay two pdfs', async () => {
-        const env_5 = { stack: [], error: void 0, hasError: false };
-        try {
-            const pdf1 = __addDisposableResource(env_5, await createPdf(1), true);
-            const pdf2 = __addDisposableResource(env_5, await createPdf(1), true);
-            const overlaid = __addDisposableResource(env_5, await overlayPdfs(pdf1.path, pdf2.path), true);
-            const count = await getPdfPageCount(overlaid.path);
-            expect(count).toBe(1);
-        }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
-        }
-        finally {
-            const result_5 = __disposeResources(env_5);
-            if (result_5)
-                await result_5;
-        }
-    });
-    it('overlayPdfs with repeat should overlay and respect repeat option', async () => {
-        const env_6 = { stack: [], error: void 0, hasError: false };
-        try {
-            const pdf1 = __addDisposableResource(env_6, await createPdf(1), true);
-            const pdf2 = __addDisposableResource(env_6, await createPdf(1), true);
-            const overlaid = __addDisposableResource(env_6, await overlayPdfs(pdf1.path, pdf2.path, { repeat: true }), true);
-            const count = await getPdfPageCount(overlaid.path);
-            expect(count).toBe(1);
-        }
-        catch (e_6) {
-            env_6.error = e_6;
-            env_6.hasError = true;
-        }
-        finally {
-            const result_6 = __disposeResources(env_6);
-            if (result_6)
-                await result_6;
-        }
-    });
-    it('should throw descriptive error on qpdf failure', async () => {
-        await expect(getPdfPageCount('non-existent.pdf')).rejects.toThrow(/qpdf: open non-existent.pdf: No such file or directory/);
-    });
-});

package/process/tests/spawn.test.d.ts

@@ -1 +0,0 @@
-export {};

package/process/tests/spawn.test.js

@@ -1,182 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { encodeUtf8 } from '../../utils/encoding.js';
-import { toReadableStream } from '../../utils/stream/to-readable-stream.js';
-import { spawnCommand, spawnWaitCommand, spawnWaitReadCommand } from '../spawn.js';
-describe('spawn', () => {
-    describe('spawnCommand', () => {
-        it('should spawn a command and wait for completion', async () => {
-            const process = await spawnCommand('sh', ['-c', 'exit 0']);
-            const result = await process.wait();
-            expect(result.code).toBe(0);
-        });
-        it('should throw on non-zero exit code', async () => {
-            const process = await spawnCommand('sh', ['-c', 'echo "error message" >&2; exit 1']);
-            await expect(process.wait()).rejects.toThrow('error message');
-        });
-        it('should handle process terminated by signal', async () => {
-            const process = await spawnCommand('sh', ['-c', 'kill -9 $$']);
-            await expect(process.wait()).rejects.toThrow('Process exited with code null and signal SIGKILL');
-        });
-        it('should buffer stdout and allow multiple reads', async () => {
-            const process = await spawnCommand('sh', ['-c', 'echo "hello world"']);
-            await process.wait();
-            const output1 = await process.readOutput();
-            const output2 = await process.readOutput();
-            const outputBytes = await process.readOutputBytes();
-            expect(output1.trim()).toBe('hello world');
-            expect(output1).toBe(output2);
-            expect(new TextDecoder().decode(outputBytes).trim()).toBe('hello world');
-        });
-        it('should buffer stderr and allow multiple reads', async () => {
-            const process = await spawnCommand('sh', ['-c', 'echo "error message" >&2']);
-            await process.wait();
-            const error1 = await process.readError();
-            const error2 = await process.readError();
-            const errorBytes = await process.readErrorBytes();
-            expect(error1.trim()).toBe('error message');
-            expect(error1).toBe(error2);
-            expect(new TextDecoder().decode(errorBytes).trim()).toBe('error message');
-        });
-        it('should handle different write data types', async () => {
-            const process1 = await spawnCommand('cat');
-            await process1.write(toReadableStream(encodeUtf8('stream\n')));
-            expect(await process1.readOutput()).toBe('stream\n');
-            const process2 = await spawnCommand('cat');
-            await process2.write(encodeUtf8('bytes\n'));
-            expect(await process2.readOutput()).toBe('bytes\n');
-            const process3 = await spawnCommand('cat');
-            await process3.write('string\n');
-            expect(await process3.readOutput()).toBe('string\n');
-        });
-        it('should handle background writes and error propagation', async () => {
-            const process = await spawnCommand('cat');
-            process.writeInBackground('test data');
-            const result = await process.waitRead('string');
-            expect(result.output).toBe('test data');
-        });
-        it('should handle errors in writeInBackground', async () => {
-            const process = await spawnCommand('sh', ['-c', 'exit 0']);
-            await process.writable.close();
-            process.writeInBackground('this should fail');
-        });
-        it('should handle non-zero exit code with empty stderr', async () => {
-            const process = await spawnCommand('sh', ['-c', 'exit 1']);
-            await expect(process.wait()).rejects.toThrow('Process exited with code 1 and signal null.');
-        });
-        it('should support manual handleNonZeroExitCode', async () => {
-            const process = await spawnCommand('sh', ['-c', 'exit 1']);
-            process.handleNonZeroExitCode();
-            await expect(process.wait()).rejects.toThrow();
-        });
-        it('should handle errors when reading error text in nonZeroExitCodeError', async () => {
-            // Mock TextDecoder to throw
-            const originalTextDecoder = global.TextDecoder;
-            global.TextDecoder = vi.fn().mockImplementation(() => ({
-                decode: () => { throw new Error('mock error'); },
-            }));
-            try {
-                const process = await spawnCommand('sh', ['-c', 'exit 1']);
-                await expect(process.wait()).rejects.toThrow('Process exited with code 1 and signal null.');
-            }
-            finally {
-                global.TextDecoder = originalTextDecoder;
-            }
-        });
-        it('should support passing options as second argument', async () => {
-            const process = await spawnCommand('sh', { arguments: ['-c', 'exit 0'] });
-            const result = await process.wait();
-            expect(result.code).toBe(0);
-        });
-        it('should support separate args and options', async () => {
-            const process = await spawnCommand('sh', ['-c', 'exit 0'], { workingDirectory: '.' });
-            const result = await process.wait();
-            expect(result.code).toBe(0);
-        });
-        it('should handle explicit undefined options', async () => {
-            const process = await spawnCommand('sh', ['-c', 'exit 0'], undefined);
-            const result = await process.wait();
-            expect(result.code).toBe(0);
-        });
-        it('should wait without options', async () => {
-            const process = await spawnCommand('sh', ['-c', 'exit 0']);
-            const result = await process.wait(undefined);
-            expect(result.code).toBe(0);
-        });
-        it('should handle command only', async () => {
-            const process = await spawnCommand('ls');
-            const result = await process.wait();
-            expect(result.code).toBe(0);
-        });
-    });
-    describe('spawnWaitCommand', () => {
-        it('should wait for command and return result', async () => {
-            const result = await spawnWaitCommand('sh', ['-c', 'exit 0']);
-            expect(result.code).toBe(0);
-        });
-        it('should throw on error by default', async () => {
-            await expect(spawnWaitCommand('sh', ['-c', 'exit 1'])).rejects.toThrow();
-        });
-        it('should support separate args and options', async () => {
-            const result = await spawnWaitCommand('sh', ['-c', 'exit 0'], { workingDirectory: '.' });
-            expect(result.code).toBe(0);
-        });
-        it('should support passing options directly', async () => {
-            const result = await spawnWaitCommand('sh', { arguments: ['-c', 'exit 0'] });
-            expect(result.code).toBe(0);
-        });
-        it('should support command only', async () => {
-            const result = await spawnWaitCommand('ls');
-            expect(result.code).toBe(0);
-        });
-        it('should handle explicit undefined options', async () => {
-            const result = await spawnWaitCommand('sh', ['-c', 'exit 0'], undefined);
-            expect(result.code).toBe(0);
-        });
-        it('should NOT throw on error if throwOnNonZeroExitCode is false', async () => {
-            const result = await spawnWaitCommand('sh', ['-c', 'exit 1'], { throwOnNonZeroExitCode: false });
-            expect(result.code).toBe(1);
-        });
-    });
-    describe('spawnWaitReadCommand', () => {
-        it('should wait and read output', async () => {
-            const result = await spawnWaitReadCommand('string', 'sh', ['-c', 'echo "test"']);
-            expect(result.output.trim()).toBe('test');
-        });
-        it('should read binary output', async () => {
-            const result = await spawnWaitReadCommand('binary', 'sh', ['-c', 'echo "test"']);
-            expect(result.output).toBeInstanceOf(Uint8Array);
-        });
-        it('should include error in exception', async () => {
-            await expect(spawnWaitReadCommand('string', 'sh', ['-c', 'echo "fail" >&2; exit 1'])).rejects.toThrow('fail');
-        });
-        it('should support options object', async () => {
-            const result = await spawnWaitReadCommand('string', 'sh', { arguments: ['-c', 'echo "test"'] });
-            expect(result.output.trim()).toBe('test');
-        });
-        it('should support separate args and options', async () => {
-            const result = await spawnWaitReadCommand('string', 'sh', ['-c', 'echo "test"'], { workingDirectory: '.' });
-            expect(result.output.trim()).toBe('test');
-        });
-        it('should support command only', async () => {
-            const result = await spawnWaitReadCommand('string', 'ls');
-            expect(result.code).toBe(0);
-        });
-        it('should NOT throw on error if throwOnNonZeroExitCode is false', async () => {
-            const result = await spawnWaitReadCommand('string', 'sh', ['-c', 'echo "fail" >&2; exit 1'], { throwOnNonZeroExitCode: false });
-            expect(result.code).toBe(1);
-            expect(result.error.trim()).toBe('fail');
-        });
-        it('should handle explicit undefined options', async () => {
-            const result = await spawnWaitReadCommand('string', 'sh', ['-c', 'echo "test"'], undefined);
-            expect(result.output.trim()).toBe('test');
-        });
-        it('should wait and read binary output without options', async () => {
-            const result = await spawnWaitReadCommand('binary', 'sh', ['-c', 'echo "test"']);
-            expect(result.output).toBeInstanceOf(Uint8Array);
-        });
-        it('should wait and read with explicit undefined options', async () => {
-            const result = await spawnWaitReadCommand('string', 'sh', ['-c', 'echo "test"'], undefined);
-            expect(result.output.trim()).toBe('test');
-        });
-    });
-});

package/rate-limit/tests/postgres-rate-limiter.test.d.ts

@@ -1 +0,0 @@
-export {};

package/rate-limit/tests/postgres-rate-limiter.test.js

@@ -1,84 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { RateLimiterProvider } from '../../rate-limit/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
-describe('PostgresRateLimiter Integration Tests', () => {
-    let injector;
-    let rateLimiter;
-    const limiterName = `test-limiter-${Date.now()}`;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { rateLimiter: true } }));
-        const rateLimiterProvider = injector.resolve(RateLimiterProvider);
-        rateLimiter = rateLimiterProvider.get(limiterName, {
-            burstCapacity: 10,
-            refillInterval: 500, // 10 tokens per 500ms -> 1 token per 50ms
-        });
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    }, 15000);
-    it('should acquire tokens successfully', async () => {
-        const resource = 'res-1';
-        const result = await rateLimiter.tryAcquire(resource, 5);
-        expect(result).toBe(true);
-        const result2 = await rateLimiter.tryAcquire(resource, 5);
-        expect(result2).toBe(true);
-        const result3 = await rateLimiter.tryAcquire(resource, 1);
-        expect(result3).toBe(false);
-    });
-    it('should refill tokens over time', async () => {
-        const resource = 'res-2';
-        await rateLimiter.tryAcquire(resource, 10);
-        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-        // Wait for 1 token (50ms) + buffer
-        await timeout(75);
-        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(true);
-        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-    });
-    it('should refund tokens', async () => {
-        const resource = 'res-3';
-        await rateLimiter.tryAcquire(resource, 10);
-        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-        await rateLimiter.refund(resource, 5);
-        expect(await rateLimiter.tryAcquire(resource, 5)).toBe(true);
-        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-    });
-    it('should handle fractional tokens', async () => {
-        const resource = 'res-4';
-        await rateLimiter.tryAcquire(resource, 9.5);
-        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-        expect(await rateLimiter.tryAcquire(resource, 0.5)).toBe(true);
-    });
-    it('should handle concurrent acquisitions', async () => {
-        const resource = 'res-concurrent';
-        // Initialize
-        await rateLimiter.tryAcquire(resource, 0);
-        const results = await Promise.all(Array.from({ length: 20 }).map(() => rateLimiter.tryAcquire(resource, 1)));
-        const successCount = results.filter(Boolean).length;
-        // We expect 10, but allow up to 12 if tokens refilled during the Promise.all
-        expect(successCount).toBeGreaterThanOrEqual(10);
-        expect(successCount).toBeLessThanOrEqual(12);
-    }, 15000);
-    it('should always allow zero or negative cost', async () => {
-        const resource = 'res-zero';
-        expect(await rateLimiter.tryAcquire(resource, 0)).toBe(true);
-        expect(await rateLimiter.tryAcquire(resource, -1)).toBe(true);
-    });
-    it('should reject cost greater than burst capacity', async () => {
-        const resource = 'res-large';
-        // Burst capacity is 10
-        expect(await rateLimiter.tryAcquire(resource, 11)).toBe(false);
-    });
-    it('should cap tokens at burst capacity on refill', async () => {
-        const resource = 'res-refill-cap';
-        // Drain
-        await rateLimiter.tryAcquire(resource, 10);
-        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-        // Wait for full refill (500ms) + extra
-        await timeout(600);
-        // Should only have 10 tokens
-        expect(await rateLimiter.tryAcquire(resource, 10)).toBe(true);
-        // Should be empty again immediately
-        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-    });
-});

package/renderer/tests/renderer.test.d.ts

@@ -1 +0,0 @@
-export {};

package/renderer/tests/renderer.test.js

@@ -1,88 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { renderD2 } from '../d2.js';
-import { renderGraphviz } from '../graphviz.js';
-import { renderTypst } from '../typst.js';
-describe('renderer', () => {
-    describe('renderGraphviz', () => {
-        it('should render a simple graph with options', async () => {
-            const source = 'graph { a -- b }';
-            const result = await renderGraphviz(source, {
-                format: 'svg',
-                engine: 'dot',
-                graphAttributes: { rankdir: 'LR' },
-                nodeAttributes: { color: 'red' },
-                edgeAttributes: { style: 'dashed' },
-                scale: 2,
-                quiet: true,
-            });
-            const svg = new TextDecoder().decode(result);
-            expect(svg).toContain('<svg');
-            expect(svg).toContain('stroke="red"');
-            expect(svg).toContain('stroke-dasharray');
-        });
-        it('should throw on invalid graphviz source', async () => {
-            const source = 'invalid graph {';
-            await expect(renderGraphviz(source)).rejects.toThrow();
-        });
-    });
-    describe('renderD2', () => {
-        it('should render a simple d2 diagram with options', async () => {
-            const source = 'x -> y';
-            const result = await renderD2(source, {
-                format: 'svg',
-                layout: 'dagre',
-                theme: 1,
-                darkTheme: 200,
-                pad: 20,
-                sketch: true,
-                center: true,
-                animateInterval: 1000,
-                noXmlTag: true,
-                salt: 'test',
-                omitVersion: true,
-                target: '*',
-                scale: 0.5,
-            });
-            const svg = new TextDecoder().decode(result);
-            expect(svg).toContain('<svg');
-        });
-        it('should throw on invalid d2 source', async () => {
-            const source = 'invalid {';
-            await expect(renderD2(source)).rejects.toThrow();
-        });
-    });
-    describe('renderTypst', () => {
-        it('should render a simple typst document with options', async () => {
-            const source = 'Hello World';
-            const result = await renderTypst(source, {
-                format: 'svg',
-                ppi: 300,
-                pages: ['1', { from: 1, to: 1 }],
-                ignoreSystemFonts: true,
-                creationTimestamp: Date.now(),
-                root: '/',
-                fontPaths: ['/tmp'],
-                pdfStandard: '1.7',
-            });
-            const svg = new TextDecoder().decode(result);
-            expect(svg).toContain('<svg');
-            expect(svg).toContain('typst-text');
-        });
-        it('should render to docx (via pandoc) with options', async () => {
-            const source = 'Hello World';
-            // pandoc --from typst --to docx --output - -
-            const result = await renderTypst(source, {
-                format: 'docx',
-                docxReferenceFile: undefined, // Testing the branch
-            });
-            expect(result).toBeInstanceOf(Uint8Array);
-            // Docx is a zip file, it should start with PK
-            expect(result[0]).toBe(0x50); // P
-            expect(result[1]).toBe(0x4B); // K
-        });
-        it('should throw on invalid typst source', async () => {
-            const source = '#invalid_func()';
-            await expect(renderTypst(source)).rejects.toThrow();
-        });
-    });
-});

package/rpc/tests/rpc.integration.test.d.ts

@@ -1 +0,0 @@
-export {};