@typespec/html-program-viewer 0.70.0-dev.0 → 0.70.0-dev.2

package/dist/{manifest-DR_CKuUi.js → manifest-uxZ2CVxd.js}

@@ -1,6 +1,6 @@
 const manifest = {
   "version": "1.0.0-rc.1",
-  "commit": "8d8982d1807b64ff053bcf9ed89a22c8d1d994fe"
+  "commit": "34733d7d8f55b3bd12be9f3b2be115dbde3c014b"
 };
 
 export { manifest as default };

package/dist/react/index.js

@@ -28794,6 +28794,14 @@ defineKit({
     },
 });
 
+defineKit({
+    entity: {
+        isAssignableTo: createDiagnosable(function (source, target, diagnosticTarget) {
+            return this.program.checker.isTypeAssignableTo(source, target, diagnosticTarget ?? source);
+        }),
+    },
+});
+
 /**
  * Creates a shallow copy of a rekeyable map.
  *
@@ -31165,6 +31173,26 @@ defineKit({
     },
 });
 
+defineKit({
+    intrinsic: {
+        get any() {
+            return this.program.checker.anyType;
+        },
+        get error() {
+            return this.program.checker.errorType;
+        },
+        get never() {
+            return this.program.checker.neverType;
+        },
+        get null() {
+            return this.program.checker.nullType;
+        },
+        get void() {
+            return this.program.checker.voidType;
+        },
+    },
+});
+
 class InvalidNumericError extends Error {
     code = "InvalidNumeric";
 }
@@ -31571,6 +31599,12 @@ defineKit({
     },
 });
 
+defineKit({
+    resolve: createDiagnosable(function (reference) {
+        return this.program.resolveTypeOrValueReference(reference);
+    }),
+});
+
 defineKit({
     scalar: {
         is(type) {
@@ -31828,6 +31862,46 @@ defineKit({
         isUserDefined(type) {
             return getLocationContext(this.program, type).type === "project";
         },
+        inNamespace(type, namespace) {
+            // A namespace is always in itself
+            if (type === namespace) {
+                return true;
+            }
+            // Handle types with known containers
+            switch (type.kind) {
+                case "ModelProperty":
+                    if (type.model) {
+                        return this.type.inNamespace(type.model, namespace);
+                    }
+                    break;
+                case "EnumMember":
+                    return this.type.inNamespace(type.enum, namespace);
+                case "UnionVariant":
+                    return this.type.inNamespace(type.union, namespace);
+                case "Operation":
+                    if (type.interface) {
+                        return this.type.inNamespace(type.interface, namespace);
+                    }
+                    // Operations that belong to a namespace directly will be handled in the generic case
+                    break;
+            }
+            // Generic case handles all other types
+            if ("namespace" in type && type.namespace) {
+                return this.type.inNamespace(type.namespace, namespace);
+            }
+            // If we got this far, the type does not belong to the namespace
+            return false;
+        },
+        isAssignableTo: createDiagnosable(function (source, target, diagnosticTarget) {
+            return this.program.checker.isTypeAssignableTo(source, target, diagnosticTarget ?? source);
+        }),
+        resolve: createDiagnosable(function (reference, kind) {
+            const [type, diagnostics] = this.program.resolveTypeReference(reference);
+            if (type && kind && type.kind !== kind) {
+                throw new Error(`Type kind mismatch: expected ${kind}, got ${type.kind}`);
+            }
+            return [type, diagnostics];
+        }),
     },
 });
 
@@ -31856,25 +31930,43 @@ defineKit({
             const variants = Array.from(union.variants.values()).filter(filterFn);
             return this.union.create({ variants });
         },
-        create(desc) {
+        create(descOrChildren) {
+            let descriptor;
+            if (Array.isArray(descOrChildren)) {
+                // Build a descriptor from the children
+                descriptor = {
+                    decorators: [],
+                    variants: descOrChildren.map((child) => {
+                        const memberDoc = getDoc(this.program, child);
+                        return this.unionVariant.create({
+                            type: child,
+                            decorators: memberDoc ? [[$doc, memberDoc]] : undefined,
+                        });
+                    }),
+                };
+            }
+            else {
+                // Already a descriptor
+                descriptor = descOrChildren;
+            }
             const union = this.program.checker.createType({
                 kind: "Union",
-                name: desc.name,
-                decorators: decoratorApplication(this, desc.decorators),
+                name: descriptor.name,
+                decorators: decoratorApplication(this, descriptor.decorators),
                 variants: createRekeyableMap(),
                 get options() {
                     return Array.from(this.variants.values()).map((v) => v.type);
                 },
-                expression: desc.name === undefined,
+                expression: descriptor.name === undefined,
             });
-            if (Array.isArray(desc.variants)) {
-                for (const variant of desc.variants) {
+            if (Array.isArray(descriptor.variants)) {
+                for (const variant of descriptor.variants) {
                     union.variants.set(variant.name, variant);
                     variant.union = union;
                 }
             }
-            else if (desc.variants) {
-                for (const [name, value] of Object.entries(desc.variants)) {
+            else if (descriptor.variants) {
+                for (const [name, value] of Object.entries(descriptor.variants)) {
                     union.variants.set(name, this.unionVariant.create({ name, type: this.literal.create(value) }));
                 }
             }
@@ -32016,6 +32108,19 @@ defineKit({
         isScalar(type) {
             return type.valueKind === "ScalarValue";
         },
+        isAssignableTo: createDiagnosable(function (source, target, diagnosticTarget) {
+            return this.program.checker.isTypeAssignableTo(source, target, diagnosticTarget ?? source);
+        }),
+        resolve: createDiagnosable(function (reference, kind) {
+            const [value, diagnostics] = this.program.resolveTypeOrValueReference(reference);
+            if (value && !isValue(value)) {
+                return [undefined, diagnostics];
+            }
+            if (value && kind && value.valueKind !== kind) {
+                throw new Error(`Value kind mismatch: expected ${kind}, got ${value.valueKind}`);
+            }
+            return [value, diagnostics];
+        }),
     },
 });
 
@@ -32067,9 +32172,11 @@ function createTypekit(realm) {
                 }
                 return proxyWrapper;
             }
-            // Only wrap objects marked as Typekit namespaces
-            if (typeof value === "object" && value !== null && isTypekitNamespace(value)) {
-                return new Proxy(value, handler); // Wrap namespace objects
+            // Wrap objects to ensure their functions are bound correctly, avoid wrapping `get` accessors
+            if (typeof value === "object" &&
+                value !== null &&
+                !Reflect.getOwnPropertyDescriptor(target, prop)?.get) {
+                return new Proxy(value, handler);
             }
             return value;
         },
@@ -32077,10 +32184,6 @@ function createTypekit(realm) {
     const proxy = new Proxy(tk, handler);
     return proxy;
 }
-// Helper function to check if an object is a Typekit namespace
-function isTypekitNamespace(obj) {
-    return obj && !!obj[TypekitNamespaceSymbol];
-}
 // #region Default Typekit
 const DEFAULT_REALM = Symbol.for("TypeSpec.Typekit.DEFAULT_TYPEKIT_REALM");
 function _$(arg) {
@@ -32320,9 +32423,22 @@ class Realm {
     get types() {
         return this.#types;
     }
-    static realmForType = new WeakMap();
+    static realmForType = singleton("Realm.realmForType", () => new WeakMap());
 }
 _a = Realm;
+/**
+ * Create a singleton instance that is shared across the process.
+ * This is to have a true singleton even if multiple instance of the compiler/library are loaded.
+ * @param key - The key to use for the singleton.
+ * @param init - The function to call to create the singleton.
+ */
+function singleton(key, init) {
+    const sym = Symbol.for(key);
+    if (!globalThis[sym]) {
+        globalThis[sym] = init();
+    }
+    return globalThis[sym];
+}
 
 /**
  * The fixed set of options for each of the kinds of delimited lists in TypeSpec.
@@ -34000,7 +34116,7 @@ let manifest;
 try {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    manifest = (await import('../manifest-DR_CKuUi.js')).default;
+    manifest = (await import('../manifest-uxZ2CVxd.js')).default;
 }
 catch {
     const name = "../dist/manifest.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/html-program-viewer",
-  "version": "0.70.0-dev.0",
+  "version": "0.70.0-dev.2",
   "author": "Microsoft Corporation",
   "description": "TypeSpec library for emitting an html view of the program.",
   "homepage": "https://typespec.io",
@@ -56,8 +56,8 @@
     "@types/react-dom": "~18.3.0",
     "@typespec/compiler": "^1.0.0-rc.1",
     "@vitejs/plugin-react": "~4.3.4",
-    "@vitest/coverage-v8": "^3.0.9",
-    "@vitest/ui": "^3.0.9",
+    "@vitest/coverage-v8": "^3.1.2",
+    "@vitest/ui": "^3.1.2",
     "c8": "^10.1.3",
     "rimraf": "~6.0.1",
     "typescript": "~5.8.2",
@@ -65,7 +65,7 @@
     "vite-plugin-checker": "^0.9.1",
     "vite-plugin-dts": "4.5.3",
     "vite-plugin-node-polyfills": "^0.23.0",
-    "vitest": "^3.0.9",
+    "vitest": "^3.1.2",
     "@typespec/react-components": "^0.57.0"
   },
   "scripts": {