@tsonic/frontend 0.0.64 → 0.0.65

package/dist/surface/js-surface-shims.js

@@ -1,332 +0,0 @@
-export const JS_SURFACE_GLOBALS_SHIMS = `
-import type { int, long, double } from "@tsonic/core/types.js";
-import type { List } from "@tsonic/dotnet/System.Collections.Generic.js";
-
-declare global {
-  interface String {
-    readonly length: int;
-    toUpperCase(): string;
-    toLowerCase(): string;
-    trim(): string;
-    trimStart(): string;
-    trimEnd(): string;
-    substring(start: int, end?: int): string;
-    slice(start: int, end?: int): string;
-    indexOf(searchString: string, position?: int): int;
-    lastIndexOf(searchString: string, position?: int): int;
-    startsWith(searchString: string, position?: int): boolean;
-    endsWith(searchString: string, endPosition?: int): boolean;
-    includes(searchString: string, position?: int): boolean;
-    replace(searchValue: string, replaceValue: string): string;
-    replaceAll(searchValue: string, replaceValue: string): string;
-    repeat(count: int): string;
-    padStart(targetLength: int, padString?: string): string;
-    padEnd(targetLength: int, padString?: string): string;
-    charAt(index: int): string;
-    charCodeAt(index: int): int;
-    split(separator: string, limit?: int): List<string>;
-    at(index: int): string;
-    concat(...strings: string[]): string;
-    localeCompare(compareString: string): int;
-    match(pattern: string | RegExp): List<string> | undefined;
-    search(pattern: string | RegExp): int;
-  }
-
-  interface Array<T> {
-    readonly length: int;
-    at(index: int): T;
-    concat(...items: T[]): T[];
-    every(callback: (value: T) => boolean): boolean;
-    filter(callback: (value: T) => boolean): T[];
-    filter(callback: (value: T, index: int) => boolean): T[];
-    find(callback: (value: T) => boolean): T | undefined;
-    find(callback: (value: T, index: int) => boolean): T | undefined;
-    findIndex(callback: (value: T) => boolean): int;
-    findIndex(callback: (value: T, index: int) => boolean): int;
-    findLast(callback: (value: T) => boolean): T | undefined;
-    findLast(callback: (value: T, index: int) => boolean): T | undefined;
-    findLastIndex(callback: (value: T) => boolean): int;
-    findLastIndex(callback: (value: T, index: int) => boolean): int;
-    flat(depth?: int): unknown[];
-    forEach(callback: (value: T) => void): void;
-    forEach(callback: (value: T, index: int) => void): void;
-    includes(searchElement: T): boolean;
-    includes(searchElement: T, fromIndex?: int): boolean;
-    indexOf(searchElement: T, fromIndex?: int): int;
-    join(separator?: string): string;
-    lastIndexOf(searchElement: T, fromIndex?: int): int;
-    map<TResult>(callback: (value: T) => TResult): TResult[];
-    map<TResult>(callback: (value: T, index: int) => TResult): TResult[];
-    reduce(callback: (previousValue: T, currentValue: T) => T): T;
-    reduce<TResult>(
-      callback: (previousValue: TResult, currentValue: T) => TResult,
-      initialValue: TResult
-    ): TResult;
-    reduceRight<TResult>(
-      callback: (previousValue: TResult, currentValue: T) => TResult,
-      initialValue: TResult
-    ): TResult;
-    slice(start?: int, end?: int): T[];
-    some(callback: (value: T) => boolean): boolean;
-  }
-
-  interface ReadonlyArray<T> {
-    readonly length: int;
-    at(index: int): T;
-    concat(...items: T[]): T[];
-    every(callback: (value: T) => boolean): boolean;
-    filter(callback: (value: T) => boolean): T[];
-    filter(callback: (value: T, index: int) => boolean): T[];
-    find(callback: (value: T) => boolean): T | undefined;
-    find(callback: (value: T, index: int) => boolean): T | undefined;
-    findIndex(callback: (value: T) => boolean): int;
-    findIndex(callback: (value: T, index: int) => boolean): int;
-    findLast(callback: (value: T) => boolean): T | undefined;
-    findLast(callback: (value: T, index: int) => boolean): T | undefined;
-    findLastIndex(callback: (value: T) => boolean): int;
-    findLastIndex(callback: (value: T, index: int) => boolean): int;
-    flat(depth?: int): unknown[];
-    forEach(callback: (value: T) => void): void;
-    forEach(callback: (value: T, index: int) => void): void;
-    includes(searchElement: T): boolean;
-    includes(searchElement: T, fromIndex?: int): boolean;
-    indexOf(searchElement: T, fromIndex?: int): int;
-    join(separator?: string): string;
-    lastIndexOf(searchElement: T, fromIndex?: int): int;
-    map<TResult>(callback: (value: T) => TResult): TResult[];
-    map<TResult>(callback: (value: T, index: int) => TResult): TResult[];
-    reduce(callback: (previousValue: T, currentValue: T) => T): T;
-    reduce<TResult>(
-      callback: (previousValue: TResult, currentValue: T) => TResult,
-      initialValue: TResult
-    ): TResult;
-    reduceRight<TResult>(
-      callback: (previousValue: TResult, currentValue: T) => TResult,
-      initialValue: TResult
-    ): TResult;
-    slice(start?: int, end?: int): T[];
-    some(callback: (value: T) => boolean): boolean;
-  }
-
-  interface Console {
-    log(...data: unknown[]): void;
-    error(...data: unknown[]): void;
-    warn(...data: unknown[]): void;
-    info(...data: unknown[]): void;
-    debug(...data: unknown[]): void;
-  }
-
-  const console: Console;
-
-  interface Date {
-    toString(): string;
-    toDateString(): string;
-    toTimeString(): string;
-    toISOString(): string;
-    toUTCString(): string;
-    valueOf(): long;
-    getTime(): long;
-    getFullYear(): int;
-    getMonth(): int;
-    getDate(): int;
-    getDay(): int;
-    getHours(): int;
-    getMinutes(): int;
-    getSeconds(): int;
-    getMilliseconds(): int;
-    setTime(time: long): long;
-    setFullYear(year: int, month?: int, date?: int): long;
-    setMonth(month: int, date?: int): long;
-    setDate(date: int): long;
-    setHours(hours: int, minutes?: int, seconds?: int, ms?: int): long;
-    setMinutes(minutes: int, seconds?: int, ms?: int): long;
-    setSeconds(seconds: int, ms?: int): long;
-    setMilliseconds(ms: int): long;
-  }
-
-  interface DateConstructor {
-    new (): Date;
-    new (value: string | number | long): Date;
-    new (year: int, monthIndex: int, date?: int): Date;
-    now(): long;
-    parse(s: string): long;
-    UTC(year: int, monthIndex: int, date?: int): long;
-  }
-
-  const Date: DateConstructor;
-
-  interface JSON {
-    parse<T = unknown>(text: string): T;
-    stringify(
-      value: unknown,
-      replacer?: ((this: unknown, key: string, value: unknown) => unknown) | readonly (number | string)[] | null,
-      space?: string | number | int
-    ): string;
-  }
-
-  const JSON: JSON;
-
-  interface Math {
-    readonly E: double;
-    readonly LN10: double;
-    readonly LN2: double;
-    readonly LOG2E: double;
-    readonly LOG10E: double;
-    readonly PI: double;
-    readonly SQRT1_2: double;
-    readonly SQRT2: double;
-    abs(x: double): double;
-    acos(x: double): double;
-    asin(x: double): double;
-    atan(x: double): double;
-    atan2(y: double, x: double): double;
-    ceil(x: double): double;
-    cos(x: double): double;
-    exp(x: double): double;
-    floor(x: double): double;
-    log(x: double): double;
-    max(...values: double[]): double;
-    min(...values: double[]): double;
-    pow(x: double, y: double): double;
-    random(): double;
-    round(x: double): double;
-    sin(x: double): double;
-    sqrt(x: double): double;
-    tan(x: double): double;
-    trunc(x: double): double;
-  }
-
-  const Math: Math;
-
-  interface RegExpMatchArray extends Array<string> {
-    index?: int;
-    input?: string;
-  }
-
-  interface RegExp {
-    exec(string: string): RegExpMatchArray | null;
-    test(string: string): boolean;
-    readonly source: string;
-    readonly global: boolean;
-    readonly ignoreCase: boolean;
-    readonly multiline: boolean;
-    lastIndex: int;
-  }
-
-  interface RegExpConstructor {
-    new (pattern: string | RegExp, flags?: string): RegExp;
-    (pattern: string | RegExp, flags?: string): RegExp;
-  }
-
-  const RegExp: RegExpConstructor;
-
-  interface Map<K, V> {
-    readonly size: int;
-    clear(): void;
-    delete(key: K): boolean;
-    forEach(
-      callbackfn: (value: V, key: K, map: Map<K, V>) => void,
-      thisArg?: unknown
-    ): void;
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V): this;
-    entries(): IterableIterator<[K, V]>;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-  }
-
-  interface MapConstructor {
-    new (): Map<unknown, unknown>;
-    new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
-  }
-
-  const Map: MapConstructor;
-
-  interface Set<T> {
-    readonly size: int;
-    add(value: T): this;
-    clear(): void;
-    delete(value: T): boolean;
-    forEach(
-      callbackfn: (value: T, value2: T, set: Set<T>) => void,
-      thisArg?: unknown
-    ): void;
-    has(value: T): boolean;
-    entries(): IterableIterator<[T, T]>;
-    keys(): IterableIterator<T>;
-    values(): IterableIterator<T>;
-    [Symbol.iterator](): IterableIterator<T>;
-  }
-
-  interface SetConstructor {
-    new (): Set<unknown>;
-    new <T = unknown>(values?: readonly T[] | null): Set<T>;
-  }
-
-  const Set: SetConstructor;
-
-  function parseInt(str: string, radix?: int): long | undefined;
-  function parseFloat(str: string): double;
-  function isFinite(value: double): boolean;
-  function isNaN(value: double): boolean;
-  function setTimeout(
-    handler: (...args: unknown[]) => void,
-    timeout?: int,
-    ...args: unknown[]
-  ): int;
-  function clearTimeout(id: int): void;
-  function setInterval(
-    handler: (...args: unknown[]) => void,
-    timeout?: int,
-    ...args: unknown[]
-  ): int;
-  function clearInterval(id: int): void;
-}
-
-export {};
-`;
-export const JS_SURFACE_NODE_MODULE_SHIMS = `
-declare module "node:assert" { export { assert } from "@tsonic/nodejs/index.js"; }
-declare module "assert" { export { assert } from "@tsonic/nodejs/index.js"; }
-declare module "node:buffer" { export { buffer } from "@tsonic/nodejs/index.js"; }
-declare module "buffer" { export { buffer } from "@tsonic/nodejs/index.js"; }
-declare module "node:child_process" { export { child_process } from "@tsonic/nodejs/index.js"; }
-declare module "child_process" { export { child_process } from "@tsonic/nodejs/index.js"; }
-declare module "node:crypto" { export { crypto } from "@tsonic/nodejs/index.js"; }
-declare module "crypto" { export { crypto } from "@tsonic/nodejs/index.js"; }
-declare module "node:dgram" { export { dgram } from "@tsonic/nodejs/index.js"; }
-declare module "dgram" { export { dgram } from "@tsonic/nodejs/index.js"; }
-declare module "node:dns" { export { dns } from "@tsonic/nodejs/index.js"; }
-declare module "dns" { export { dns } from "@tsonic/nodejs/index.js"; }
-declare module "node:events" { export { events } from "@tsonic/nodejs/index.js"; }
-declare module "events" { export { events } from "@tsonic/nodejs/index.js"; }
-declare module "node:fs" { export { fs } from "@tsonic/nodejs/index.js"; }
-declare module "fs" { export { fs } from "@tsonic/nodejs/index.js"; }
-declare module "node:net" { export { net } from "@tsonic/nodejs/index.js"; }
-declare module "net" { export { net } from "@tsonic/nodejs/index.js"; }
-declare module "node:os" { export { os } from "@tsonic/nodejs/index.js"; }
-declare module "os" { export { os } from "@tsonic/nodejs/index.js"; }
-declare module "node:path" { export { path } from "@tsonic/nodejs/index.js"; }
-declare module "path" { export { path } from "@tsonic/nodejs/index.js"; }
-declare module "node:process" { export { process } from "@tsonic/nodejs/index.js"; }
-declare module "process" { export { process } from "@tsonic/nodejs/index.js"; }
-declare module "node:querystring" { export { querystring } from "@tsonic/nodejs/index.js"; }
-declare module "querystring" { export { querystring } from "@tsonic/nodejs/index.js"; }
-declare module "node:readline" { export { readline } from "@tsonic/nodejs/index.js"; }
-declare module "readline" { export { readline } from "@tsonic/nodejs/index.js"; }
-declare module "node:stream" { export { stream } from "@tsonic/nodejs/index.js"; }
-declare module "stream" { export { stream } from "@tsonic/nodejs/index.js"; }
-declare module "node:timers" { export { timers } from "@tsonic/nodejs/index.js"; }
-declare module "timers" { export { timers } from "@tsonic/nodejs/index.js"; }
-declare module "node:tls" { export { tls } from "@tsonic/nodejs/index.js"; }
-declare module "tls" { export { tls } from "@tsonic/nodejs/index.js"; }
-declare module "node:url" { export { url } from "@tsonic/nodejs/index.js"; }
-declare module "url" { export { url } from "@tsonic/nodejs/index.js"; }
-declare module "node:util" { export { util } from "@tsonic/nodejs/index.js"; }
-declare module "util" { export { util } from "@tsonic/nodejs/index.js"; }
-declare module "node:zlib" { export { zlib } from "@tsonic/nodejs/index.js"; }
-declare module "zlib" { export { zlib } from "@tsonic/nodejs/index.js"; }
-`;
-//# sourceMappingURL=js-surface-shims.js.map

package/dist/surface/js-surface-shims.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"js-surface-shims.js","sourceRoot":"","sources":["../../src/surface/js-surface-shims.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgSvC,CAAC;AAEF,MAAM,CAAC,MAAM,4BAA4B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyC3C,CAAC"}

package/dist/surface/js-surface-shims.test.d.ts

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

package/dist/surface/js-surface-shims.test.d.ts.map

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

package/dist/surface/js-surface-shims.test.js

@@ -1,53 +0,0 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import { JS_SURFACE_GLOBALS_SHIMS, JS_SURFACE_NODE_MODULE_SHIMS, } from "./js-surface-shims.js";
-describe("JS Surface Shims", () => {
-    it("declares required JS runtime globals", () => {
-        const requiredGlobals = [
-            "interface String",
-            "interface Array<T>",
-            "interface ReadonlyArray<T>",
-            "const console: Console;",
-            "const Date: DateConstructor;",
-            "const JSON: JSON;",
-            "const Math: Math;",
-            "const RegExp: RegExpConstructor;",
-            "const Map: MapConstructor;",
-            "const Set: SetConstructor;",
-            "function parseInt(",
-            "function parseFloat(",
-            "function isFinite(",
-            "function isNaN(",
-            "function setTimeout(",
-            "function setInterval(",
-        ];
-        for (const token of requiredGlobals) {
-            expect(JS_SURFACE_GLOBALS_SHIMS).to.include(token);
-        }
-    });
-    it("keeps unsupported mutating Array APIs out of compiler-owned shims", () => {
-        expect(JS_SURFACE_GLOBALS_SHIMS).to.not.include("push(");
-        expect(JS_SURFACE_GLOBALS_SHIMS).to.not.include("pop(");
-        expect(JS_SURFACE_GLOBALS_SHIMS).to.not.include("splice(");
-        expect(JS_SURFACE_GLOBALS_SHIMS).to.not.include("shift(");
-        expect(JS_SURFACE_GLOBALS_SHIMS).to.not.include("unshift(");
-    });
-    it("declares node alias modules for both node:* and bare specifiers", () => {
-        const requiredNodeAliases = [
-            'declare module "node:fs" { export { fs } from "@tsonic/nodejs/index.js"; }',
-            'declare module "fs" { export { fs } from "@tsonic/nodejs/index.js"; }',
-            'declare module "node:path" { export { path } from "@tsonic/nodejs/index.js"; }',
-            'declare module "path" { export { path } from "@tsonic/nodejs/index.js"; }',
-            'declare module "node:crypto" { export { crypto } from "@tsonic/nodejs/index.js"; }',
-            'declare module "crypto" { export { crypto } from "@tsonic/nodejs/index.js"; }',
-            'declare module "node:process" { export { process } from "@tsonic/nodejs/index.js"; }',
-            'declare module "process" { export { process } from "@tsonic/nodejs/index.js"; }',
-            'declare module "node:os" { export { os } from "@tsonic/nodejs/index.js"; }',
-            'declare module "os" { export { os } from "@tsonic/nodejs/index.js"; }',
-        ];
-        for (const alias of requiredNodeAliases) {
-            expect(JS_SURFACE_NODE_MODULE_SHIMS).to.include(alias);
-        }
-    });
-});
-//# sourceMappingURL=js-surface-shims.test.js.map

package/dist/surface/js-surface-shims.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"js-surface-shims.test.js","sourceRoot":"","sources":["../../src/surface/js-surface-shims.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAC9B,OAAO,EACL,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAE/B,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAChC,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAC9C,MAAM,eAAe,GAAG;YACtB,kBAAkB;YAClB,oBAAoB;YACpB,4BAA4B;YAC5B,yBAAyB;YACzB,8BAA8B;YAC9B,mBAAmB;YACnB,mBAAmB;YACnB,kCAAkC;YAClC,4BAA4B;YAC5B,4BAA4B;YAC5B,oBAAoB;YACpB,sBAAsB;YACtB,oBAAoB;YACpB,iBAAiB;YACjB,sBAAsB;YACtB,uBAAuB;SACf,CAAC;QAEX,KAAK,MAAM,KAAK,IAAI,eAAe,EAAE,CAAC;YACpC,MAAM,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACrD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mEAAmE,EAAE,GAAG,EAAE;QAC3E,MAAM,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACzD,MAAM,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACxD,MAAM,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC3D,MAAM,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC1D,MAAM,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,GAAG,EAAE;QACzE,MAAM,mBAAmB,GAAG;YAC1B,4EAA4E;YAC5E,uEAAuE;YACvE,gFAAgF;YAChF,2EAA2E;YAC3E,oFAAoF;YACpF,+EAA+E;YAC/E,sFAAsF;YACtF,iFAAiF;YACjF,4EAA4E;YAC5E,uEAAuE;SAC/D,CAAC;QAEX,KAAK,MAAM,KAAK,IAAI,mBAAmB,EAAE,CAAC;YACxC,MAAM,CAAC,4BAA4B,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACzD,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/validation/unsupported-utility-types.d.ts

@@ -1,40 +0,0 @@
-/**
- * Centralized list of unsupported TypeScript utility types
- *
- * These utility types internally use mapped or conditional types which are not
- * supported in Tsonic. They are detected by name in TypeReferenceNode validation.
- *
- * Note: This only applies to the built-in utility types from TypeScript's lib.
- * User-defined types with these names (without type arguments) are allowed.
- */
-/**
- * Mapped-type utility types (TSN7406)
- *
- * SUPPORTED (expanded at compile time for concrete types):
- * - Partial<T>   → { [P in keyof T]?: T[P] }
- * - Required<T>  → { [P in keyof T]-?: T[P] }
- * - Readonly<T>  → { readonly [P in keyof T]: T[P] }
- * - Pick<T, K>   → { [P in K]: T[P] }
- * - Omit<T, K>   → { [P in Exclude<keyof T, K>]: T[P] }
- *
- * Note: Record<K, V> is handled separately (allowed when K is string, TSN7413 otherwise)
- * Note: ReadonlyArray<T> is NOT a mapped type - it maps to IReadOnlyList<T> and is supported
- */
-export declare const UNSUPPORTED_MAPPED_UTILITY_TYPES: Set<string>;
-/**
- * Conditional-type utility types (TSN7407)
- *
- * SUPPORTED (expanded at compile time for concrete types):
- * - Extract<T, U>    → T extends U ? T : never
- * - Exclude<T, U>    → T extends U ? never : T
- * - NonNullable<T>   → T & {}  (filters null/undefined from unions)
- * - ReturnType<T>    → T extends (...args: any) => infer R ? R : any
- * - Parameters<T>    → T extends (...args: infer P) => any ? P : never
- * - Awaited<T>       → T extends PromiseLike<infer U> ? Awaited<U> : T
- *
- * SUPPORTED (expanded at compile time for concrete constructor shapes):
- * - ConstructorParameters<T>
- * - InstanceType<T>
- */
-export declare const UNSUPPORTED_CONDITIONAL_UTILITY_TYPES: Set<string>;
-//# sourceMappingURL=unsupported-utility-types.d.ts.map

package/dist/validation/unsupported-utility-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unsupported-utility-types.d.ts","sourceRoot":"","sources":["../../src/validation/unsupported-utility-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gCAAgC,aAG3C,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qCAAqC,aAAsB,CAAC"}

package/dist/validation/unsupported-utility-types.js

@@ -1,43 +0,0 @@
-/**
- * Centralized list of unsupported TypeScript utility types
- *
- * These utility types internally use mapped or conditional types which are not
- * supported in Tsonic. They are detected by name in TypeReferenceNode validation.
- *
- * Note: This only applies to the built-in utility types from TypeScript's lib.
- * User-defined types with these names (without type arguments) are allowed.
- */
-/**
- * Mapped-type utility types (TSN7406)
- *
- * SUPPORTED (expanded at compile time for concrete types):
- * - Partial<T>   → { [P in keyof T]?: T[P] }
- * - Required<T>  → { [P in keyof T]-?: T[P] }
- * - Readonly<T>  → { readonly [P in keyof T]: T[P] }
- * - Pick<T, K>   → { [P in K]: T[P] }
- * - Omit<T, K>   → { [P in Exclude<keyof T, K>]: T[P] }
- *
- * Note: Record<K, V> is handled separately (allowed when K is string, TSN7413 otherwise)
- * Note: ReadonlyArray<T> is NOT a mapped type - it maps to IReadOnlyList<T> and is supported
- */
-export const UNSUPPORTED_MAPPED_UTILITY_TYPES = new Set([
-// Partial, Required, Readonly, Pick, Omit are now supported
-// They are expanded to IrObjectType in type-converter/utility-types.ts
-]);
-/**
- * Conditional-type utility types (TSN7407)
- *
- * SUPPORTED (expanded at compile time for concrete types):
- * - Extract<T, U>    → T extends U ? T : never
- * - Exclude<T, U>    → T extends U ? never : T
- * - NonNullable<T>   → T & {}  (filters null/undefined from unions)
- * - ReturnType<T>    → T extends (...args: any) => infer R ? R : any
- * - Parameters<T>    → T extends (...args: infer P) => any ? P : never
- * - Awaited<T>       → T extends PromiseLike<infer U> ? Awaited<U> : T
- *
- * SUPPORTED (expanded at compile time for concrete constructor shapes):
- * - ConstructorParameters<T>
- * - InstanceType<T>
- */
-export const UNSUPPORTED_CONDITIONAL_UTILITY_TYPES = new Set([]);
-//# sourceMappingURL=unsupported-utility-types.js.map

package/dist/validation/unsupported-utility-types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unsupported-utility-types.js","sourceRoot":"","sources":["../../src/validation/unsupported-utility-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,IAAI,GAAG,CAAS;AAC9D,4DAA4D;AAC5D,uEAAuE;CACxE,CAAC,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,IAAI,GAAG,CAAS,EAAE,CAAC,CAAC"}