convex 1.44.0 → 1.45.0-alpha.0

package/src/browser/sync/request_manager.test.ts

@@ -1,273 +0,0 @@
-import { test, expect, beforeEach, vi } from "vitest";
-import { RequestManager } from "./request_manager.js";
-import { Long } from "../../vendor/long.js";
-import { ActionRequest, MutationRequest } from "./protocol.js";
-import { instantiateDefaultLogger } from "../logging.js";
-
-let requestManager: RequestManager;
-let markConnectionStateDirty: ReturnType<typeof vi.fn<() => void>>;
-
-beforeEach(() => {
-  markConnectionStateDirty = vi.fn<() => void>();
-  requestManager = new RequestManager(
-    instantiateDefaultLogger({ verbose: false }),
-    markConnectionStateDirty,
-  );
-});
-
-test("hasIncompleteRequests", () => {
-  // Starts false.
-  expect(requestManager.hasIncompleteRequests()).toBe(false);
-
-  // When we request a mutation it becomes true.
-  let message: MutationRequest = {
-    type: "Mutation",
-    requestId: 0,
-    udfPath: "myMutation",
-    args: [],
-  };
-  let _ = requestManager.request(message, true);
-  expect(requestManager.hasIncompleteRequests()).toBe(true);
-
-  // Request a second mutation and receive the first's response.
-  // Should still have an outstanding mutation.
-  message = {
-    type: "Mutation",
-    requestId: 1,
-    udfPath: "myMutation",
-    args: [],
-  };
-  _ = requestManager.request(message, true);
-  requestManager.onResponse({
-    type: "MutationResponse",
-    requestId: 0,
-    success: true,
-    result: null,
-    ts: Long.fromNumber(0),
-    logLines: [],
-  });
-  expect(requestManager.hasIncompleteRequests()).toBe(true);
-
-  // When the second response comes back we no longer have any outstanding mutations.
-  requestManager.onResponse({
-    type: "MutationResponse",
-    requestId: 1,
-    success: true,
-    result: null,
-    ts: Long.fromNumber(0),
-    logLines: [],
-  });
-  expect(requestManager.hasIncompleteRequests()).toBe(false);
-});
-
-/**
- * A test that simulates a WebSocket disconnection half-way through the mutation
- * flow.
- */
-test("mutation retries", async () => {
-  // Request a mutation.
-  const message: MutationRequest = {
-    type: "Mutation",
-    requestId: 0,
-    udfPath: "myMutation",
-    args: [],
-  };
-  const mutationRequest = requestManager.request(message, true);
-
-  // Receive the response.
-  requestManager.onResponse({
-    type: "MutationResponse",
-    requestId: 0,
-    success: true,
-    result: null,
-    ts: Long.fromNumber(0),
-    logLines: [],
-  });
-  expect(requestManager.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Pretend that we become disconnected and reconnect.
-  // We should request the mutation because we haven't transitioned past the
-  // timestamp the mutation was committed at yet.
-  expect(requestManager.restart()).toEqual([message]);
-  expect(requestManager.hasSyncedPastLastReconnect()).toBe(false);
-
-  // Receive another response (because we restarted and requested it again)
-  requestManager.onResponse({
-    type: "MutationResponse",
-    requestId: 0,
-    success: true,
-    result: null,
-    ts: Long.fromNumber(0),
-    logLines: [],
-  });
-
-  // Transition to ts=1
-  requestManager.removeCompleted(Long.fromNumber(1));
-  expect(requestManager.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Return the result of the mutation now that we've transitioned past the
-  // mutation timestamp.
-  const result = await mutationRequest;
-  expect(result).toEqual({ success: true, value: null, logLines: [] });
-
-  // The if we restart now, the mutation should no longer be re-requested.
-  expect(requestManager.restart()).toEqual([]);
-});
-
-/**
- * Another disconnection test
- *
- * This time upon reconnect we transition past the mutation immediately when we
- * reconnect (before getting the second response).
- */
-test("mutation retries with transition", async () => {
-  // Request a mutation.
-  const message: MutationRequest = {
-    type: "Mutation",
-    requestId: 0,
-    udfPath: "myMutation",
-    args: [],
-  };
-  const mutationRequest = requestManager.request(message, true);
-
-  // Receive the response.
-  requestManager.onResponse({
-    type: "MutationResponse",
-    requestId: 0,
-    success: true,
-    result: null,
-    ts: Long.fromNumber(0),
-    logLines: [],
-  });
-  expect(requestManager.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Pretend that we become disconnected and reconnect.
-  // We should request the mutation because we haven't transitioned past the
-  // timestamp the mutation was committed at yet.
-  expect(requestManager.restart()).toEqual([message]);
-  expect(requestManager.hasSyncedPastLastReconnect()).toBe(false);
-
-  // Transition to ts=1
-  requestManager.removeCompleted(Long.fromNumber(1));
-  expect(requestManager.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Return the result of the mutation now that we've transitioned past the
-  // mutation timestamp.
-  const result = await mutationRequest;
-  expect(result).toEqual({ success: true, value: null, logLines: [] });
-
-  // The if we restart now, the mutation should no longer be re-requested because
-  // we've already observed it.
-  expect(requestManager.restart()).toEqual([]);
-  expect(requestManager.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Receive another response (because we requested it again).
-  // This response just needs to not crash the client.
-  requestManager.onResponse({
-    type: "MutationResponse",
-    requestId: 0,
-    success: true,
-    result: null,
-    ts: Long.fromNumber(0),
-    logLines: [],
-  });
-});
-
-/**
- * A test that simulates a WebSocket disconnection half-way through the action
- * flow. Makes sure the action doe not get retried.
- */
-test("actions are retried only if unsent", async () => {
-  // Request a mutation.
-  const message1: ActionRequest = {
-    type: "Action",
-    requestId: 0,
-    udfPath: "myAction1",
-    args: [],
-  };
-  const actionRequest1 = requestManager.request(message1, true);
-  const message2: ActionRequest = {
-    type: "Action",
-    requestId: 1,
-    udfPath: "myAction2",
-    args: [],
-  };
-  const actionRequest2 = requestManager.request(message2, false);
-
-  // Pretend that we become disconnected and reconnect.
-  // We should only resend message2.
-  expect(requestManager.restart()).toEqual([message2]);
-
-  // The sent action promise should resolve with an error.
-  const result = await actionRequest1;
-  expect(result).toEqual({
-    success: false,
-    errorMessage: "Connection lost while action was in flight",
-    logLines: [],
-  });
-
-  // If we reconnect again, we should not retry anything. The second promise
-  // should also resolve with an error.
-  expect(requestManager.restart()).toEqual([]);
-  const result2 = await actionRequest2;
-  expect(result2).toEqual({
-    success: false,
-    errorMessage: "Connection lost while action was in flight",
-    logLines: [],
-  });
-});
-
-test("markConnectionStateDirty is called on state changes", () => {
-  expect(markConnectionStateDirty).toHaveBeenCalledTimes(0);
-
-  // Adding a request should trigger the callback
-  const message: MutationRequest = {
-    type: "Mutation",
-    requestId: 0,
-    udfPath: "myMutation",
-    args: [],
-  };
-  void requestManager.request(message, true);
-  expect(markConnectionStateDirty).toHaveBeenCalledTimes(1);
-
-  // Response for actions triggers callback immediately, but mutations need to complete
-  const actionMessage: ActionRequest = {
-    type: "Action",
-    requestId: 1,
-    udfPath: "myAction",
-    args: [],
-  };
-  void requestManager.request(actionMessage, true);
-  expect(markConnectionStateDirty).toHaveBeenCalledTimes(2);
-
-  // Action response should trigger callback
-  requestManager.onResponse({
-    type: "ActionResponse",
-    requestId: 1,
-    success: true,
-    result: null,
-    logLines: [],
-  });
-  expect(markConnectionStateDirty).toHaveBeenCalledTimes(3);
-
-  // First make a mutation response that gets completed
-  requestManager.onResponse({
-    type: "MutationResponse",
-    requestId: 0,
-    success: true,
-    result: null,
-    ts: Long.fromNumber(0),
-    logLines: [],
-  });
-
-  // removeCompleted should trigger the callback when mutations complete
-  markConnectionStateDirty.mockClear();
-  const completedRequests = requestManager.removeCompleted(Long.fromNumber(1));
-  expect(completedRequests.size).toBe(1);
-  expect(markConnectionStateDirty).toHaveBeenCalledTimes(1);
-
-  // restart should trigger the callback
-  markConnectionStateDirty.mockClear();
-  requestManager.restart();
-  expect(markConnectionStateDirty).toHaveBeenCalledTimes(1);
-});

package/src/bundler/fs.test.ts

@@ -1,86 +0,0 @@
-import { test, expect } from "vitest";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { nodeFs } from "./fs.js";
-
-test("nodeFs filesystem operations behave as expected", async () => {
-  const tmpdir = fs.mkdtempSync(`${os.tmpdir()}${path.sep}`);
-  try {
-    const parentDirPath = path.join(tmpdir, "testdir");
-    const dirPath = path.join(parentDirPath, "nestedDir");
-    const filePath = path.join(dirPath, "text.txt");
-
-    // Test making and listing directories.
-    try {
-      nodeFs.mkdir(dirPath);
-      throw new Error(
-        "Expected `mkdir` to fail because the containing directory doesn't exist yet.",
-      );
-    } catch (e: any) {
-      expect(e.code).toEqual("ENOENT");
-    }
-
-    nodeFs.mkdir(parentDirPath);
-    nodeFs.mkdir(dirPath);
-    try {
-      nodeFs.mkdir(dirPath);
-      throw new Error("Expected `mkdir` to fail without allowExisting");
-    } catch (e: any) {
-      expect(e.code).toEqual("EEXIST");
-    }
-    nodeFs.mkdir(dirPath, { allowExisting: true });
-
-    const dirEntries = nodeFs.listDir(parentDirPath);
-    expect(dirEntries).toHaveLength(1);
-    expect(dirEntries[0].name).toEqual("nestedDir");
-
-    const nestedEntries = nodeFs.listDir(dirPath);
-    expect(nestedEntries).toHaveLength(0);
-
-    // Test file based methods for nonexistent paths.
-    expect(nodeFs.exists(filePath)).toEqual(false);
-    try {
-      nodeFs.stat(filePath);
-      throw new Error("Expected `stat` to fail for nonexistent paths");
-    } catch (e: any) {
-      expect(e.code).toEqual("ENOENT");
-    }
-    try {
-      nodeFs.readUtf8File(filePath);
-      throw new Error("Expected `readUtf8File` to fail for nonexistent paths");
-    } catch (e: any) {
-      expect(e.code).toEqual("ENOENT");
-    }
-    try {
-      nodeFs.access(filePath);
-      throw new Error("Expected `access` to fail for nonexistent paths");
-    } catch (e: any) {
-      expect(e.code).toEqual("ENOENT");
-    }
-
-    // Test creating a file and accessing it.
-    const message = "it's trompo o'clock";
-    nodeFs.writeUtf8File(filePath, message);
-    expect(nodeFs.exists(filePath)).toEqual(true);
-    nodeFs.stat(filePath);
-    expect(nodeFs.readUtf8File(filePath)).toEqual(message);
-    nodeFs.access(filePath);
-
-    // Test unlinking a file and directory.
-    try {
-      nodeFs.unlink(dirPath);
-      throw new Error("Expected `unlink` to fail on a directory");
-    } catch (e: any) {
-      if (os.platform() === "linux") {
-        expect(e.code).toEqual("EISDIR");
-      } else {
-        expect(e.code).toEqual("EPERM");
-      }
-    }
-    nodeFs.unlink(filePath);
-    expect(nodeFs.exists(filePath)).toEqual(false);
-  } finally {
-    fs.rmSync(tmpdir, { recursive: true });
-  }
-});

package/src/bundler/index.test.ts

@@ -1,210 +0,0 @@
-import { expect, test, afterEach, vi } from "vitest";
-import { oneoffContext } from "./context.js";
-
-// Although these tests are run as ESM by ts-lint, this file is built as both
-// CJS and ESM by TypeScript so normal recipes like `__dirname` for getting the
-// script directory don't work.
-const dirname = "src/bundler";
-
-import {
-  bundle,
-  doesImportConvexHttpRouter,
-  entryPoints,
-  entryPointsByEnvironment,
-  useNodeDirectiveRegex,
-  mustBeIsolate,
-} from "./index.js";
-
-const sorted = <T>(arr: T[], key: (el: T) => any): T[] => {
-  const newArr = [...arr];
-  const cmp = (a: T, b: T) => {
-    if (key(a) < key(b)) return -1;
-    if (key(a) > key(b)) return 1;
-    return 0;
-  };
-  return newArr.sort(cmp);
-};
-
-const getDefaultCtx = async () => {
-  return await oneoffContext({
-    url: undefined,
-    adminKey: undefined,
-    envFile: undefined,
-  });
-};
-
-afterEach(() => {
-  vi.resetAllMocks();
-});
-
-test("bundle function is present", () => {
-  expect(typeof bundle).toEqual("function");
-});
-
-test("bundle finds JavaScript functions", async () => {
-  const fixtureDir = dirname + "/test_fixtures/js/project01";
-  const ctx = await getDefaultCtx();
-  const entryPoints = await entryPointsByEnvironment(ctx, fixtureDir);
-  const bundles = sorted(
-    (
-      await bundle({
-        ctx,
-        dir: fixtureDir,
-        entryPoints: entryPoints.isolate,
-        generateSourceMaps: false,
-        platform: "browser",
-      })
-    ).modules,
-    (b) => b.path,
-  ).filter((bundle) => !bundle.path.includes("_deps"));
-  expect(bundles).toHaveLength(2);
-  expect(bundles[0].path).toEqual("bar.js");
-  expect(bundles[1].path).toEqual("foo.js");
-});
-
-test("bundle resolves node async_hooks shim", async () => {
-  const fixtureDir = dirname + "/test_fixtures/js/project_with_node_shims";
-  const ctx = await getDefaultCtx();
-  const entryPoints = await entryPointsByEnvironment(ctx, fixtureDir);
-  const bundles = sorted(
-    (
-      await bundle({
-        ctx,
-        dir: fixtureDir,
-        entryPoints: entryPoints.isolate,
-        generateSourceMaps: false,
-        platform: "browser",
-      })
-    ).modules,
-    (b) => b.path,
-  ).filter((bundle) => !bundle.path.includes("_deps"));
-
-  expect(bundles).toHaveLength(1);
-  expect(bundles[0].path).toEqual("uses_node_shims.js");
-});
-
-test("returns true when simple import httpRouter found", async () => {
-  const result = await doesImportConvexHttpRouter(`
-    import { httpRouter } from "convex/server";
-
-    export const val = 1;
-    `);
-  expect(result).toBeTruthy();
-});
-
-test("returns false when httpRouter is not imported", async () => {
-  const result = await doesImportConvexHttpRouter(`
-    export const val = 1;
-    `);
-  expect(result).toBeFalsy();
-});
-
-test("returns true when multiline import httpRouter found", async () => {
-  const result = await doesImportConvexHttpRouter(`
-    import {
-      httpRouter
-    } from "convex/server";
-
-    export const val = 1;
-    `);
-  expect(result).toBeTruthy();
-});
-
-test("returns true when httpRouter is imported with alias", async () => {
-  const result = await doesImportConvexHttpRouter(`
-    import { httpRouter as router } from "convex/server";
-
-    export const val = 1;
-    `);
-  expect(result).toBeTruthy();
-});
-
-test("returns true when httpRouter is imported with alias and multiline", async () => {
-  const result = await doesImportConvexHttpRouter(`
-    import {
-      httpRouter as router
-    } from "convex/server";
-
-    export const val = 1;
-    `);
-  expect(result).toBeTruthy();
-});
-
-test("returns true when multiple imports and httpRouter is imported", async () => {
-  const result = await doesImportConvexHttpRouter(`
-    import { cronJobs, httpRouter } from "convex/server";
-
-    export const val = 1;
-    `);
-  expect(result).toBeTruthy();
-});
-
-test("bundle warns about https.js|ts at top level", async () => {
-  const fixtureDir = dirname + "/test_fixtures/js/project_with_https";
-  const logSpy = vi.spyOn(process.stderr, "write");
-  await entryPoints(await getDefaultCtx(), fixtureDir);
-  expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("https"));
-});
-
-test("bundle does not warn about https.js|ts which is not at top level", async () => {
-  const fixtureDir =
-    dirname + "/test_fixtures/js/project_with_https_not_at_top_level";
-  const logSpy = vi.spyOn(process.stderr, "write");
-  await entryPoints(await getDefaultCtx(), fixtureDir);
-  expect(logSpy).toHaveBeenCalledTimes(0);
-});
-
-test("bundle does not warn about https.js|ts which does not import httpRouter", async () => {
-  const fixtureDir =
-    dirname + "/test_fixtures/js/project_with_https_without_router";
-  const logSpy = vi.spyOn(process.stderr, "write");
-  await entryPoints(await getDefaultCtx(), fixtureDir);
-  expect(logSpy).toHaveBeenCalledTimes(0);
-});
-
-test("use node regex", () => {
-  // Double quotes
-  expect('"use node";').toMatch(useNodeDirectiveRegex);
-  // Single quotes
-  expect("'use node';").toMatch(useNodeDirectiveRegex);
-  // No semi column
-  expect('"use node"').toMatch(useNodeDirectiveRegex);
-  expect("'use node'").toMatch(useNodeDirectiveRegex);
-  // Extra spaces
-  expect('   "use node"   ').toMatch(useNodeDirectiveRegex);
-  expect("   'use node'   ").toMatch(useNodeDirectiveRegex);
-
-  // Nothing
-  expect("").not.toMatch(useNodeDirectiveRegex);
-  // No quotes
-  expect("use node").not.toMatch(useNodeDirectiveRegex);
-  // In a comment
-  expect('// "use node";').not.toMatch(useNodeDirectiveRegex);
-  // Typo
-  expect('"use nod";').not.toMatch(useNodeDirectiveRegex);
-  // Extra quotes
-  expect('""use node"";').not.toMatch(useNodeDirectiveRegex);
-  expect("''use node'';").not.toMatch(useNodeDirectiveRegex);
-  // Extra semi colons
-  expect('"use node";;;').not.toMatch(useNodeDirectiveRegex);
-  // Twice
-  expect('"use node";"use node";').not.toMatch(useNodeDirectiveRegex);
-});
-
-test("must use isolate", () => {
-  expect(mustBeIsolate("http.js")).toBeTruthy();
-  expect(mustBeIsolate("http.mjs")).toBeTruthy();
-  expect(mustBeIsolate("http.ts")).toBeTruthy();
-  expect(mustBeIsolate("crons.js")).toBeTruthy();
-  expect(mustBeIsolate("crons.cjs")).toBeTruthy();
-  expect(mustBeIsolate("crons.ts")).toBeTruthy();
-  expect(mustBeIsolate("schema.js")).toBeTruthy();
-  expect(mustBeIsolate("schema.jsx")).toBeTruthy();
-  expect(mustBeIsolate("schema.ts")).toBeTruthy();
-  expect(mustBeIsolate("schema.js")).toBeTruthy();
-
-  expect(mustBeIsolate("http.sample.js")).not.toBeTruthy();
-  expect(mustBeIsolate("https.js")).not.toBeTruthy();
-  expect(mustBeIsolate("schema2.js")).not.toBeTruthy();
-  expect(mustBeIsolate("schema/http.js")).not.toBeTruthy();
-});

package/src/bundler/test_fixtures/js/project01/bar.js

@@ -1,4 +0,0 @@
-// eslint-disable-next-line  @typescript-eslint/no-unused-vars
-async function _notExported() {
-  return 0;
-}

package/src/bundler/test_fixtures/js/project01/file with spaces.js

@@ -1 +0,0 @@
-export const a = null;

package/src/bundler/test_fixtures/js/project01/foo.js

@@ -1,9 +0,0 @@
-export default async function defaultExport() {
-  return 1;
-}
-
-export async function exported() {
-  return 2;
-}
-
-export const notAFunction = 123;

package/src/bundler/test_fixtures/js/project_with_https/https.js

@@ -1,9 +0,0 @@
-import { httpRouter } from "convex/server";
-
-export const val = 1;
-
-export let otherHttp = 20;
-
-const http = httpRouter();
-
-export default http;

package/src/bundler/test_fixtures/js/project_with_https_not_at_top_level/default.js

@@ -1,3 +0,0 @@
-export default async function defaultExport() {
-  return 1;
-}

package/src/bundler/test_fixtures/js/project_with_https_not_at_top_level/more_code/https.js

@@ -1,5 +0,0 @@
-import { httpRouter } from "convex/server";
-
-const http = httpRouter();
-
-export default http;

package/src/bundler/test_fixtures/js/project_with_https_without_router/https.js

@@ -1 +0,0 @@
-export const val = 1;

package/src/bundler/test_fixtures/js/project_with_node_shims/uses_node_shims.js

@@ -1,4 +0,0 @@
-import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
-
-export const als = new AsyncLocalStorage();
-export const resource = new AsyncResource("test");

package/src/cli/codegen_templates/api.test.ts

@@ -1,18 +0,0 @@
-import { test, expect } from "vitest";
-import { importPath, moduleIdentifier } from "./api.js";
-
-test("importPath", () => {
-  expect(importPath("foo.ts")).toEqual("foo");
-  expect(importPath("foo.tsx")).toEqual("foo");
-  expect(importPath("foo\\bar.ts")).toEqual("foo/bar");
-  expect(importPath("foo/bar.ts")).toEqual("foo/bar");
-});
-
-test("moduleIdentifier", () => {
-  expect(moduleIdentifier("foo.ts")).toEqual("foo");
-  // This mapping is ambiguous! This is a codegen implementation detail so
-  // this can be changed without requiring changes beyond running codegen.
-  expect(moduleIdentifier("foo/bar.ts")).toEqual("foo_bar");
-  expect(moduleIdentifier("foo_bar.ts")).toEqual("foo_bar");
-  expect(moduleIdentifier("foo-bar.ts")).toEqual("foo_bar");
-});

package/src/cli/codegen_templates/common.test.ts

@@ -1,52 +0,0 @@
-import { describe, test, expect } from "vitest";
-import { compareModulePaths } from "./common.js";
-
-describe("compareModulePaths", () => {
-  test("matches default sort order for forward slash paths", () => {
-    const paths = ["fooBaz.ts", "foo/bar.ts", "foo.ts"];
-    expect([...paths].sort(compareModulePaths)).toEqual([...paths].sort());
-  });
-
-  test("orders Windows paths identically to their POSIX equivalents", () => {
-    const posixPaths = ["fooBaz.ts", "foo/bar.ts", "foo.ts"];
-    const windowsPaths = posixPaths.map((p) => p.replace(/\//g, "\\"));
-
-    const sortedPosix = [...posixPaths].sort(compareModulePaths);
-    const sortedWindows = [...windowsPaths].sort(compareModulePaths);
-
-    expect(sortedPosix).toEqual(["foo.ts", "foo/bar.ts", "fooBaz.ts"]);
-    expect(sortedWindows.map((p) => p.replace(/\\/g, "/"))).toEqual(
-      sortedPosix,
-    );
-  });
-
-  test("default sort diverges on this input, demonstrating the bug", () => {
-    // "/" (0x2F) sorts before letters while "\" (0x5C) sorts after them,
-    // so the OS-native forms of the same file set sort differently.
-    const windowsPaths = ["fooBaz.ts", "foo\\bar.ts", "foo.ts"];
-    expect([...windowsPaths].sort()).toEqual([
-      "foo.ts",
-      "fooBaz.ts",
-      "foo\\bar.ts",
-    ]);
-    expect([...windowsPaths].sort(compareModulePaths)).toEqual([
-      "foo.ts",
-      "foo\\bar.ts",
-      "fooBaz.ts",
-    ]);
-  });
-
-  test("sorts nested directories before longer sibling file names", () => {
-    const paths = ["a/b/c.ts", "aZ.ts", "a.ts", "a/b.ts"];
-    expect([...paths].sort(compareModulePaths)).toEqual([
-      "a.ts",
-      "a/b.ts",
-      "a/b/c.ts",
-      "aZ.ts",
-    ]);
-    const windows = paths.map((p) => p.replace(/\//g, "\\"));
-    expect(
-      [...windows].sort(compareModulePaths).map((p) => p.replace(/\\/g, "/")),
-    ).toEqual(["a.ts", "a/b.ts", "a/b/c.ts", "aZ.ts"]);
-  });
-});