typespec-typescript-emitter 1.2.0 → 2.0.1

package/src/resolve/types/Union.ts

@@ -0,0 +1,52 @@
+import { getDoc, Union } from "@typespec/compiler";
+import { Resolvable } from "../Resolvable.js";
+import {
+  Resolver,
+  ResolverOptions,
+  ResolverResult,
+} from "../Resolvable_helpers.js";
+
+export class ResolvableUnion extends Resolvable<Union> {
+  protected expectedTypeKind = "Union";
+
+  public override async hasVisibility(
+    opts: ResolverOptions<Resolver>,
+    out: ResolverResult<Resolver>,
+  ): Promise<boolean> {
+    if (await super.hasVisibility(opts, out)) return true;
+    for (const v of Array.from(this._t.variants)) {
+      if (await Resolvable.hasVisibility(v[1].type, opts, out, this._t))
+        return true;
+    }
+    return false;
+  }
+
+  protected async type(
+    opts: ResolverOptions<Resolver.Type>,
+    out: ResolverResult<Resolver.Type>,
+  ): Promise<void> {
+    if (opts.emitDocs) {
+      out.doc = getDoc(opts.program, this._t);
+    }
+    const results: string[] = [];
+    for (const v of Array.from(this._t.variants)) {
+      const resolved = await this.resolveNested(v[1].type, opts, out, false);
+      out.imports.push(...resolved.imports);
+      results.push(resolved.resolved.value);
+    }
+    out.resolved.append(results.join(" | "));
+  }
+
+  protected async typeguard(
+    opts: ResolverOptions<Resolver.Typeguard>,
+    out: ResolverResult<Resolver.Typeguard>,
+  ): Promise<void> {
+    const results: string[] = [];
+    for (const v of Array.from(this._t.variants)) {
+      const resolved = await this.resolveNested(v[1].type, opts, out);
+      out.imports.push(...resolved.imports);
+      results.push(`(${resolved.resolved.value})`);
+    }
+    out.resolved.append(results.join(" || "));
+  }
+}

package/test/helpers/integrationTest-novis.tsp

@@ -0,0 +1,51 @@
+import "@typespec/http";
+
+using TypeSpec.Http;
+
+@service()
+namespace test {
+  enum AdminLevel {
+    Level1,
+    Level2
+  }
+
+  scalar Name extends string;
+  alias Timestamp = unixTimestamp32;
+
+  model Resource {
+    id_onlyRead: uint32,
+    name: Name,
+    metadata: {
+      created_onlyRead: Timestamp,
+      user: uint32,
+      username: string,
+      adminLevel?: AdminLevel | null
+    }
+  }
+
+  /** Retrieves an instance of the ressource */
+  @get
+  op getResource(): {
+    @statusCode status: 200,
+    @body body: Resource
+  };
+
+  /** Creates a resource */
+  @put
+  op postResource(@body body: Resource | inner.InnerModel): OkResponse;
+
+  @route("/inner")
+  namespace inner {
+    model InnerModel {
+      resourceName: string,
+      resource: test.Resource
+    }
+
+    model InnerModel2 {
+      level: AdminLevel
+    }
+
+    @delete
+    op del(@body body: InnerModel | InnerModel2): OkResponse | UnauthorizedResponse;
+  }
+}

package/test/helpers/integrationTest.tsp

@@ -0,0 +1,53 @@
+import "@typespec/http";
+
+using TypeSpec.Http;
+
+@service()
+namespace test {
+  enum AdminLevel {
+    Level1,
+    Level2
+  }
+
+  scalar Name extends string;
+  alias Timestamp = unixTimestamp32;
+
+  model Resource {
+    @visibility(Lifecycle.Read)
+    id_onlyRead: uint32,
+    name: Name,
+    metadata: {
+      @visibility
+      created_onlyRead: Timestamp,
+      user: uint32,
+      username: string,
+      adminLevel?: AdminLevel | null
+    }
+  }
+
+  /** Retrieves an instance of the ressource */
+  @get
+  op getResource(): {
+    @statusCode status: 200,
+    @body body: Resource
+  };
+
+  /** Creates a resource */
+  @put
+  op postResource(@body body: Resource | inner.InnerModel): OkResponse;
+
+  @route("/inner")
+  namespace inner {
+    model InnerModel {
+      resourceName: string,
+      resource: test.Resource
+    }
+
+    model InnerModel2 {
+      level: AdminLevel
+    }
+
+    @delete
+    op del(@body body: InnerModel | InnerModel2): OkResponse | UnauthorizedResponse;
+  }
+}

package/test/helpers/largeModel.tsp

@@ -0,0 +1,40 @@
+scalar dateType extends unixTimestamp32;
+alias aliasedString = string;
+alias aliasedModel = {str: string, fl: float, nested: {int: int32}};
+
+model test {
+  @visibility(Lifecycle.Read)
+  id_onlyRead: uint64,
+  name: string,
+  aliasedName?: aliasedString,
+  date: utcDateTime,
+  time: plainTime,
+  @visibility(Lifecycle.Create)
+  created_onlyCreate: unixTimestamp32,
+  @visibility(Lifecycle.Read, Lifecycle.Query)
+  tuple_strIntModel_readQuery: [string, int16, {inmodel_union: null | unknown}],
+  nested?: {
+    availability: boolean
+  },
+  array: string[],
+  array_union: (string | int16)[],
+  record: Record<string>,
+  record_union: Record<string | int16>,
+  @visibility(Lifecycle.Delete, Lifecycle.Query)
+  nested_deleteQuery: {
+    @visibility(Lifecycle.Query)
+    str_onlyQuery: string,
+    aliasedModel: aliasedModel,
+    modelWithVis: {
+      a: "a",
+      @visibility(Lifecycle.Delete)
+      seven_onlyDelete: 7
+    }
+  },
+  nestedInnerVis: {
+    unk?: unknown,
+    @visibility(Lifecycle.Update)
+    void_onlyUpdate: void
+  },
+  tupleWithUnion: [string, int32 | boolean]
+}

package/test/{runner.ts → helpers/runner.ts}

@@ -2,4 +2,4 @@ import { createTester } from "@typespec/compiler/testing";
 
 export const runner = createTester(".", {
   libraries: ["@typespec/http", "typespec-typescript-emitter"], // Add other libraries you depend on in your tests
-});
+}).importLibraries();

package/test/helpers/ts.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+
+export const validateTS = (code: string): true | string => {
+  const out = ts.transpileModule(code, {
+    reportDiagnostics: true,
+    compilerOptions: { noEmit: true },
+  });
+  return out.diagnostics === undefined || out.diagnostics.length === 0
+    ? true
+    : out.diagnostics.map((d) => d.messageText).join(", ");
+};

package/test/helpers/wrapper.ts

@@ -0,0 +1,144 @@
+import { Type } from "@typespec/compiler";
+import { resolveVirtualPath } from "@typespec/compiler/testing";
+import { expect, it } from "vitest";
+import { EmitterOptions } from "../../src/lib";
+import { Resolvable } from "../../src/resolve/Resolvable";
+import { Resolver, ResolverResult } from "../../src/resolve/Resolvable_helpers";
+import { runner } from "./runner";
+import { validateTS } from "./ts";
+
+export const defaultConfig: Omit<EmitterOptions, "out-dir"> = {
+  "root-namespaces": ["test"],
+  "enable-types": true,
+  "enable-typeguards": false,
+  "enable-routes": false,
+  "enable-routed-typemap": false,
+  "string-nominal-enums": true,
+  "serializable-date-types": true,
+};
+
+type Filename = string;
+export const expectEmit = <T extends string | Record<Filename, string>>(
+  desc: string,
+  input: T,
+  target: T,
+  config?: Partial<typeof defaultConfig>,
+  outFilename?: T extends string ? string : never,
+): void => {
+  it(desc, async () => {
+    if (!outFilename) outFilename = "test.ts" as any;
+    const emitter = await runner.emit("typespec-typescript-emitter", {
+      ...structuredClone(defaultConfig),
+      ...(config ?? {}),
+    });
+    const instance = await emitter.createInstance();
+    const result = await instance.compileAndDiagnose(input);
+
+    // check for diagnostics
+    if (result[1].length > 0) console.error(result[1]);
+    expect(result[1].length).toBe(0);
+
+    // check all files against target
+    if (typeof target === "string") {
+      if (!result[0].outputs[outFilename!])
+        console.error(
+          `${outFilename!} not found in ${Object.keys(result[0].outputs)}`,
+        );
+      expect(result[0].outputs[outFilename!].replaceAll("\r", "").trim()).toBe(
+        target.replaceAll("\r", "").trim(),
+      );
+    } else {
+      for (const t of Object.entries(target)) {
+        expect(
+          (
+            await result[0].program.host.readFile(
+              resolveVirtualPath(t[0]).replaceAll("\r", "").trim(),
+            )
+          ).text.trim(),
+        ).toBe(t[1].replaceAll("\r", "").trim());
+      }
+    }
+  });
+};
+
+export const expectResolution = (
+  r: Resolver,
+  args: {
+    /** Kind of the type we expect to get (@typespec/compiler.Type['kind']) */
+    type: string;
+    /** Description of the test, only used for test output */
+    desc?: string;
+    /** Source TSP */
+    source: string;
+    /** Expected TS output */
+    target: string;
+    /** Either `true` (all okay) or error message */
+    test?: (t: Type, r: ResolverResult<Resolver.Type>) => true | string;
+    /** Name of the type to compile; used to get type from program. */
+    typename?: string;
+    /** Partion EmitterOptions config object */
+    config?: Partial<typeof defaultConfig>;
+    /**
+     * If set, the TSP output will be put through this before checking typescript validity.
+     * Default is `type test = ${output}`.
+     * If set to null, typescript syntax will not be checked.
+     */
+    typescriptTransformer?: ((tsp: string) => string) | null;
+    /** If set, does not check if resolution output is "truthy" */
+    noTruthyCheck?: boolean;
+  },
+) => {
+  if (!args.typename) args.typename = "test";
+  if (!args.config) {
+    args.config = defaultConfig;
+  } else {
+    args.config = { ...defaultConfig, ...args.config };
+  }
+
+  /** Removes all leading and trailing whitespace on each line. */
+  const transformResult = (s: string): string =>
+    s
+      .split("\n")
+      .map((l) => l.trim())
+      .join("");
+  if (args.typescriptTransformer === undefined)
+    args.typescriptTransformer = (tsp) => `type test = ${tsp};`;
+
+  it(`${r === Resolver.Type ? "type" : "typeguard"}: ${args.type} ${args.desc ?? ""}`, async () => {
+    const { program } = await runner.compile(
+      args.source,
+      args.config as Record<string, any>,
+    );
+    // get compiled type
+    const result = program.resolveTypeReference(args.typename!);
+    // check for diagnostics
+    if (result[1].length > 0) console.error(result[1]);
+    expect(result[1].length).toBe(0); // no diagnostics
+    // type compiled and expected type.kind?
+    expect(result[0]).toBeDefined();
+    expect(result[0]?.kind).toBe(args.type);
+    // resolve to typescript
+    const resolved = await Resolvable.resolve(r, result[0]!, {
+      program,
+      options: args.config as EmitterOptions,
+      nestlevel: 0,
+      rootType: null,
+      typemap: [],
+      emitDocs: false,
+    });
+    // check if valid typescript
+    if (args.typescriptTransformer !== null) {
+      const tsCode = args.typescriptTransformer!(resolved.resolved.value);
+      let tsValidity = validateTS(tsCode);
+      if (tsValidity !== true) tsValidity += `\nTypescript: ${tsCode}`;
+      expect(tsValidity).toBe(true);
+    }
+    if (!args.noTruthyCheck) expect(resolved.resolved.value).toBeTruthy();
+    // check generated typescript content
+    expect(transformResult(resolved.resolved.value)).toBe(
+      transformResult(transformResult(args.target)),
+    );
+    if (args.test !== undefined)
+      expect(await args.test(result[0]!, resolved)).toBe(true);
+  });
+};

package/test/routes/routes.target.ts

@@ -0,0 +1,35 @@
+
+
+
+/*
+ * This file is automatically generated by typespec-typescript-emitter.
+ * 
+ * You should not change or manipulate this file, as it will be overwritten.
+ * Instead, change the underlying spec.
+ */
+
+
+export const routes_test = {
+  /** Retrieves an instance of the ressource */
+  getResource: {
+    verb: 'GET',
+    path: '/',
+    getUrl: (): string => `/`,
+    auth: [null]
+  },
+  /** Creates a resource */
+  postResource: {
+    verb: 'PUT',
+    path: '/',
+    getUrl: (): string => `/`,
+    auth: [null]
+  },
+  inner: {
+    del: {
+      verb: 'DELETE',
+      path: '/inner',
+      getUrl: (): string => `/inner`,
+      auth: [null]
+    }
+  }
+} as const;

package/test/routes/routes.test.ts

@@ -0,0 +1,22 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+import { expectEmit } from "../helpers/wrapper";
+
+const files: Record<string, string> = {
+  ["main.tsp"]: readFileSync(
+    join(__dirname, "..", "helpers", "integrationTest.tsp"),
+    "utf8",
+  ),
+};
+
+expectEmit(
+  "route object",
+  files,
+  {
+    "routes_test.ts": `/* eslint-disable */${readFileSync(
+      join(__dirname, "routes.target.ts"),
+      "utf8",
+    )}`,
+  },
+  { "enable-routes": true },
+);

package/test/typeguards/combined.test.ts

@@ -0,0 +1,78 @@
+import { readFileSync } from "fs";
+import { join } from "path";
+import { Resolver } from "../../src/resolve/Resolvable_helpers";
+import { expectResolution } from "../helpers/wrapper";
+
+const input = readFileSync(
+  join(__dirname, "..", "helpers", "largeModel.tsp"),
+  "utf8",
+);
+
+const target = `
+  ((vis as any) !== Lifecycle.All && ![Lifecycle.Read].includes(vis) ? !('id_onlyRead' in undefined) : (undefined['id_onlyRead'] !== undefined && (typeof undefined['id_onlyRead'] === 'number'))) &&
+  undefined['name'] !== undefined && (typeof undefined['name'] === 'string') &&
+  undefined['aliasedName'] === undefined || (typeof undefined['aliasedName'] === 'string') &&
+  undefined['date'] !== undefined && (undefined['date'] instanceof Date) &&
+  undefined['time'] !== undefined && (typeof undefined['time'] === 'string') &&
+  ((vis as any) !== Lifecycle.All && ![Lifecycle.Create].includes(vis) ? !('created_onlyCreate' in undefined) : (
+    undefined['created_onlyCreate'] !== undefined && (undefined['created_onlyCreate'] instanceof Date)
+  )) &&
+  ((vis as any) !== Lifecycle.All && ![Lifecycle.Read, Lifecycle.Query].includes(vis) ? !('tuple_strIntModel_readQuery' in undefined) : (
+    undefined['tuple_strIntModel_readQuery'] !== undefined && (
+      Array.isArray(undefined['tuple_strIntModel_readQuery']) && (
+        typeof undefined['tuple_strIntModel_readQuery'][0] === 'string'
+      ) && (
+        typeof undefined['tuple_strIntModel_readQuery'][1] === 'number'
+      ) && (
+        undefined['tuple_strIntModel_readQuery'][2]['inmodel_union'] !== undefined && (
+          (undefined['tuple_strIntModel_readQuery'][2]['inmodel_union'] === null) || (true)
+        )
+      )
+    )
+  )) &&
+  undefined['nested'] === undefined || (undefined['nested']['availability'] !== undefined && (typeof undefined['nested']['availability'] === 'boolean')) &&
+  undefined['array'] !== undefined && (Array.isArray(undefined['array']) && undefined['array'].every((v) => typeof v === 'string')) &&
+  undefined['array_union'] !== undefined && (Array.isArray(undefined['array_union']) && undefined['array_union'].every((v) => (typeof v === 'string') || (typeof v === 'number'))) &&
+  undefined['record'] !== undefined && (typeof undefined['record'] === 'object' && Object.entries(undefined['record'] as Record<string, any>).every((v) => typeof v[1] === 'string')) &&
+  undefined['record_union'] !== undefined && (typeof undefined['record_union'] === 'object' && Object.entries(undefined['record_union'] as Record<string, any>).every((v) => (typeof v[1] === 'string') || (typeof v[1] === 'number'))) &&
+  ((vis as any) !== Lifecycle.All && ![Lifecycle.Delete, Lifecycle.Query].includes(vis) ? !('nested_deleteQuery' in undefined) : (
+    undefined['nested_deleteQuery'] !== undefined && (
+      ((vis as any) !== Lifecycle.All && ![Lifecycle.Query].includes(vis) ? !('str_onlyQuery' in undefined['nested_deleteQuery']) : (
+        undefined['nested_deleteQuery']['str_onlyQuery'] !== undefined && (typeof undefined['nested_deleteQuery']['str_onlyQuery'] === 'string')
+      )) &&
+      undefined['nested_deleteQuery']['aliasedModel'] !== undefined && (
+        undefined['nested_deleteQuery']['aliasedModel']['str'] !== undefined && (typeof undefined['nested_deleteQuery']['aliasedModel']['str'] === 'string') &&
+        undefined['nested_deleteQuery']['aliasedModel']['fl'] !== undefined && (typeof undefined['nested_deleteQuery']['aliasedModel']['fl'] === 'number') &&
+        undefined['nested_deleteQuery']['aliasedModel']['nested'] !== undefined && (
+          undefined['nested_deleteQuery']['aliasedModel']['nested']['int'] !== undefined && (typeof undefined['nested_deleteQuery']['aliasedModel']['nested']['int'] === 'number')
+        )
+      ) &&
+      undefined['nested_deleteQuery']['modelWithVis'] !== undefined && (
+        undefined['nested_deleteQuery']['modelWithVis']['a'] !== undefined && (undefined['nested_deleteQuery']['modelWithVis']['a'] === 'a') &&
+        ((vis as any) !== Lifecycle.All && ![Lifecycle.Delete].includes(vis) ? !('seven_onlyDelete' in undefined['nested_deleteQuery']['modelWithVis']) : (
+          undefined['nested_deleteQuery']['modelWithVis']['seven_onlyDelete'] !== undefined && (undefined['nested_deleteQuery']['modelWithVis']['seven_onlyDelete'] === 7)
+        ))
+      )
+    )
+)) &&
+  undefined['nestedInnerVis'] !== undefined && (
+    undefined['nestedInnerVis']['unk'] === undefined || (true) &&
+    ((vis as any) !== Lifecycle.All && ![Lifecycle.Update].includes(vis) ? !('void_onlyUpdate' in undefined['nestedInnerVis']) : (
+      undefined['nestedInnerVis']['void_onlyUpdate'] === undefined
+    ))
+  ) &&
+  undefined['tupleWithUnion'] !== undefined && (
+    Array.isArray(undefined['tupleWithUnion']) && (typeof undefined['tupleWithUnion'][0] === 'string') && ((typeof undefined['tupleWithUnion'][1] === 'number') || (typeof undefined['tupleWithUnion'][1] === 'boolean'))
+  )
+`;
+
+expectResolution(Resolver.Typeguard, {
+  type: "Model",
+  desc: "combined",
+  source: input,
+  target: target,
+  config: {
+    "serializable-date-types": false,
+  },
+  typescriptTransformer: null,
+});

package/test/typeguards/enum.test.ts

@@ -0,0 +1,10 @@
+import { Resolver } from "../../src/resolve/Resolvable_helpers";
+import { expectResolution } from "../helpers/wrapper";
+
+expectResolution(Resolver.Typeguard, {
+  type: "Enum",
+  source: "enum test {val1, val2}",
+  target: "", // enums don't have typeguards
+  typescriptTransformer: null,
+  noTruthyCheck: true,
+});

package/test/typeguards/model.indexed.test.ts

@@ -0,0 +1,68 @@
+import { Resolver } from "../../src/resolve/Resolvable_helpers";
+import { expectResolution } from "../helpers/wrapper";
+
+type Name = string;
+type Source = string;
+type Target = string;
+
+// because there is no accessor, we are "testing" `undefined`
+const tests: [Name, string, Source, Target][] = [
+  [
+    "Array",
+    "simple",
+    "string[]",
+    "Array.isArray(undefined) && undefined.every((v) => typeof v === 'string')",
+  ],
+  [
+    "Array",
+    "union",
+    "(string | int32)[]",
+    "Array.isArray(undefined) && undefined.every((v) => (typeof v === 'string') || (typeof v === 'number'))",
+  ],
+  [
+    "Array",
+    "tuple",
+    "[string, int32][]",
+    "Array.isArray(undefined) && undefined.every((v) => Array.isArray(v) && (typeof v[0] === 'string') && (typeof v[1] === 'number'))",
+  ],
+  [
+    "Array",
+    "model",
+    "{str: string}[]",
+    "Array.isArray(undefined) && undefined.every((v) =>v['str'] !== undefined && (typeof v['str'] === 'string')  )",
+  ],
+  [
+    "Record",
+    "simple",
+    "Record<string>",
+    "typeof undefined === 'object' && Object.entries(undefined as Record<string, any>).every((v) => typeof v[1] === 'string')",
+  ],
+  [
+    "Record",
+    "union",
+    "Record<string | int32>",
+    "typeof undefined === 'object' && Object.entries(undefined as Record<string, any>).every((v) => (typeof v[1] === 'string') || (typeof v[1] === 'number'))",
+  ],
+  [
+    "Record",
+    "tuple",
+    "Record<[string, int32]>",
+    "typeof undefined === 'object' && Object.entries(undefined as Record<string, any>).every((v) => Array.isArray(v[1]) && (typeof v[1][0] === 'string') && (typeof v[1][1] === 'number'))",
+  ],
+  [
+    "Record",
+    "model",
+    "Record<{str?: string}>",
+    "typeof undefined === 'object' && Object.entries(undefined as Record<string, any>).every((v) =>v[1]['str'] === undefined || (typeof v[1]['str'] === 'string')  )",
+  ],
+];
+
+tests.forEach((test) => {
+  expectResolution(Resolver.Typeguard, {
+    type: "Model",
+    desc: `(indexed: ${test[0]}): ${test[1]}`,
+    source: `alias test = ${test[2]};`,
+    target: test[3],
+    typescriptTransformer: null,
+  });
+});

package/test/typeguards/model.shaped.test.ts

@@ -0,0 +1,38 @@
+import { Resolver } from "../../src/resolve/Resolvable_helpers";
+import { expectResolution } from "../helpers/wrapper";
+
+const tests: [string, string][] = [
+  [
+    "{s: string}",
+    "undefined['s'] !== undefined && (typeof undefined['s'] === 'string')",
+  ],
+  [
+    "{s?: string}",
+    "undefined['s'] === undefined || (typeof undefined['s'] === 'string')",
+  ],
+  [
+    "{m: {s: string | int32}}",
+    "undefined['m'] !== undefined && (undefined['m']['s'] !== undefined && ((typeof undefined['m']['s'] === 'string') || (typeof undefined['m']['s'] === 'number')))",
+  ],
+  [
+    "{a: {s: utcDateTime}[]}",
+    "undefined['a'] !== undefined && (Array.isArray(undefined['a']) && undefined['a'].every((v) =>v['s'] !== undefined && (v['s'] instanceof Date)    ))",
+  ],
+  [
+    "{r: Record<[string, int32]>, a: string[], f: never}",
+    "undefined['r'] !== undefined && (typeof undefined['r'] === 'object' && Object.entries(undefined['r'] as Record<string, any>).every((v) => Array.isArray(v[1]) && (typeof v[1][0] === 'string') && (typeof v[1][1] === 'number'))) &&" +
+      "undefined['a'] !== undefined && (Array.isArray(undefined['a']) && undefined['a'].every((v) => typeof v === 'string')) &&" +
+      "!('f' in undefined)",
+  ],
+];
+
+tests.forEach((test) => {
+  expectResolution(Resolver.Typeguard, {
+    type: "Model",
+    desc: test[0],
+    source: `alias test = ${test[0]};`,
+    target: test[1],
+    typescriptTransformer: null,
+    config: { "serializable-date-types": false },
+  });
+});

package/test/typeguards/scalar.test.ts

@@ -0,0 +1,62 @@
+import { Scalar } from "@typespec/compiler";
+import { EmitterOptions } from "../../src/lib";
+import { Resolver } from "../../src/resolve/Resolvable_helpers";
+import { expectResolution } from "../helpers/wrapper";
+
+type Name = string;
+type Target = string;
+
+const tests: [Name, Target, Partial<EmitterOptions>?][] = [
+  ["boolean", "typeof undefined === 'boolean'"],
+  ["bytes", "undefined instanceof Uint8Array"],
+  ["duration", "typeof undefined === 'number'"],
+  ["numeric", "typeof undefined === 'number'"],
+  ["plainTime", "typeof undefined === 'string'"],
+  ["string", "typeof undefined === 'string'"],
+  ["url", "typeof undefined === 'string'"],
+
+  // date / time types
+  ...["offsetDateTime", "plainDate", "utcDateTime"].map(
+    (t) =>
+      [
+        t,
+        "undefined instanceof Date",
+        { "serializable-date-types": false },
+      ] as [string, string, any],
+  ),
+  ...["offsetDateTime", "plainDate", "utcDateTime"].map(
+    (t) =>
+      [
+        t,
+        "typeof undefined === 'string'",
+        { "serializable-date-types": true },
+      ] as [string, string, any],
+  ),
+  [
+    "unixTimestamp32",
+    "undefined instanceof Date",
+    { "serializable-date-types": false },
+  ],
+  [
+    "unixTimestamp32",
+    "typeof undefined === 'number'",
+    { "serializable-date-types": true },
+  ],
+];
+
+tests.forEach((test) => {
+  expectResolution(Resolver.Typeguard, {
+    type: "Scalar",
+    desc: test[2]
+      ? `{${Object.entries(test[2]).map((p) => `${p[0]}: ${p[1]}`)}}`
+      : undefined,
+    source: `alias test = ${test[0]};`,
+    target: test[1],
+    test: (t) =>
+      (t as Scalar).name === test[0]
+        ? true
+        : `scalar name was ${(t as Scalar).name}`,
+    config: test[2],
+    typescriptTransformer: null,
+  });
+});