@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/framework/hooks/binder.ts

@@ -1,21 +1,18 @@
+import { normalizePath } from "@typespec/compiler";
+import path from "path/posix";
 import {
-  SourceFile,
   ImportDeclarationStructure,
-  StructureKind,
   ImportSpecifierStructure,
-  Project
+  Project,
+  SourceFile,
+  StructureKind,
 } from "ts-morph";
-import { provideContext, useContext } from "../../contextManager.js";
+import { provideContext, useContext } from "../../context-manager.js";
+import { generateLocallyUniqueName } from "../../modular/helpers/naming-helpers.js";
 import { ReferenceableSymbol } from "../dependency.js";
-import { provideDependencies, useDependencies } from "./useDependencies.js";
+import { SourceFileSymbol, StaticHelperMetadata } from "../load-static-helpers.js";
 import { refkey } from "../refkey.js";
-import {
-  SourceFileSymbol,
-  StaticHelperMetadata
-} from "../load-static-helpers.js";
-import path from "path/posix";
-import { normalizePath } from "@typespec/compiler";
-import { generateLocallyUniqueName } from "../../modular/helpers/namingHelpers.js";
+import { provideDependencies, useDependencies } from "./use-dependencies.js";
 
 export interface DeclarationInfo {
   name: string;
@@ -39,11 +36,7 @@ export interface Binder {
    * @param sourceFile - The source file where the declaration is made.
    * @returns The tracked declaration name.
    */
-  trackDeclaration(
-    refkey: unknown,
-    name: string,
-    sourceFile: SourceFile
-  ): string;
+  trackDeclaration(refkey: unknown, name: string, sourceFile: SourceFile): string;
   resolveReference(refkey: unknown): string;
   resolveAllReferences(sourceRoot: string, testRoot?: string): void;
 }
@@ -69,15 +62,8 @@ class BinderImp implements Binder {
     this.useSubpathImports = options.useSubpathImports ?? false;
   }
 
-  trackDeclaration(
-    refkey: unknown,
-    name: string,
-    sourceFile: SourceFile
-  ): string {
-    const uniqueName = this.generateLocallyUniqueDeclarationName(
-      name,
-      sourceFile
-    );
+  trackDeclaration(refkey: unknown, name: string, sourceFile: SourceFile): string {
+    const uniqueName = this.generateLocallyUniqueDeclarationName(name, sourceFile);
     const declarationInfo: DeclarationInfo = { name: uniqueName, sourceFile };
     this.declarations.set(refkey, declarationInfo);
 
@@ -96,12 +82,8 @@ class BinderImp implements Binder {
    * @param sourceFile - The source file where the declaration is made.
    * @returns A unique name for the declaration within the file.
    */
-  private generateLocallyUniqueDeclarationName(
-    name: string,
-    sourceFile: SourceFile
-  ): string {
-    const existingNamesInFile =
-      this.symbolsBySourceFile.get(sourceFile) ?? new Set<string>();
+  private generateLocallyUniqueDeclarationName(name: string, sourceFile: SourceFile): string {
+    const existingNamesInFile = this.symbolsBySourceFile.get(sourceFile) ?? new Set<string>();
     return generateLocallyUniqueName(name, existingNamesInFile);
   }
 
@@ -111,10 +93,7 @@ class BinderImp implements Binder {
    * @param sourceFile - The source file where the import is made.
    * @returns A unique name for the import within the file.
    */
-  private generateLocallyUniqueImportName(
-    name: string,
-    sourceFile: SourceFile
-  ): string {
+  private generateLocallyUniqueImportName(name: string, sourceFile: SourceFile): string {
     const existingImports = (this.imports.get(sourceFile) ?? [])
       .flatMap((i) => i.namedImports as ImportSpecifierStructure[])
       .map((i) => i.alias ?? i.name);
@@ -123,15 +102,12 @@ class BinderImp implements Binder {
     const actualImports = sourceFile
       .getImportDeclarations()
       .flatMap((imp) => imp.getNamedImports())
-      .map(
-        (namedImp) => namedImp.getAliasNode()?.getText() ?? namedImp.getName()
-      );
+      .map((namedImp) => namedImp.getAliasNode()?.getText() ?? namedImp.getName());
 
-    const existingDeclarations =
-      this.symbolsBySourceFile.get(sourceFile) ?? new Set<string>();
+    const existingDeclarations = this.symbolsBySourceFile.get(sourceFile) ?? new Set<string>();
     return generateLocallyUniqueName(
       name,
-      new Set([...existingImports, ...actualImports, ...existingDeclarations])
+      new Set([...existingImports, ...actualImports, ...existingDeclarations]),
     );
   }
 
@@ -166,12 +142,9 @@ class BinderImp implements Binder {
   private addImport(
     fileWhereImportIsAdded: SourceFile,
     fileWhereImportPointsTo: SourceFile | string,
-    name: string
+    name: string,
   ): ImportSpecifierStructure {
-    const importAlias = this.generateLocallyUniqueImportName(
-      name,
-      fileWhereImportIsAdded
-    );
+    const importAlias = this.generateLocallyUniqueImportName(name, fileWhereImportIsAdded);
     let moduleSpecifier = "";
     if (typeof fileWhereImportPointsTo === "string") {
       moduleSpecifier = fileWhereImportPointsTo;
@@ -180,35 +153,30 @@ class BinderImp implements Binder {
         .getRelativePathTo(fileWhereImportPointsTo)
         .replace(".ts", ".js");
       moduleSpecifier =
-        relative.startsWith(".") || relative.startsWith("/")
-          ? relative
-          : `./${relative}`;
+        relative.startsWith(".") || relative.startsWith("/") ? relative : `./${relative}`;
     }
 
     const importStructures = this.imports.get(fileWhereImportIsAdded) || [];
 
-    let importStructure = importStructures.find(
-      (imp) => imp.moduleSpecifier === moduleSpecifier
-    );
+    let importStructure = importStructures.find((imp) => imp.moduleSpecifier === moduleSpecifier);
 
     if (!importStructure) {
       importStructure = {
         kind: StructureKind.ImportDeclaration,
         moduleSpecifier,
-        namedImports: []
+        namedImports: [],
       };
       importStructures.push(importStructure);
     }
 
-    const namedImports =
-      importStructure.namedImports as ImportSpecifierStructure[];
+    const namedImports = importStructure.namedImports as ImportSpecifierStructure[];
     let importSpecifier = namedImports.find((n) => n.name === importAlias);
 
     if (!importSpecifier) {
       importSpecifier = {
         name: name,
         alias: name === importAlias ? undefined : importAlias,
-        kind: StructureKind.ImportSpecifier
+        kind: StructureKind.ImportSpecifier,
       };
       namedImports.push(importSpecifier);
     }
@@ -225,21 +193,15 @@ class BinderImp implements Binder {
    * e.g. "src/static-helpers/serialization/get-binary-response.ts"
    *   -> "#platform/static-helpers/serialization/get-binary-response"
    */
-  private getPlatformImportSpecifier(
-    declarationSourceFile: SourceFile
-  ): string | undefined {
+  private getPlatformImportSpecifier(declarationSourceFile: SourceFile): string | undefined {
     if (!this.useSubpathImports) return undefined;
     const filePath = declarationSourceFile.getFilePath();
     const srcIndex = filePath.indexOf("/src/");
     if (srcIndex === -1) return undefined;
     // Check if a -browser.mts or -react-native.mts sibling exists
     const basePath = filePath.replace(/\.ts$/, "");
-    const hasBrowserVariant = this.project.getSourceFile(
-      basePath + "-browser.mts"
-    );
-    const hasReactNativeVariant = this.project.getSourceFile(
-      basePath + "-react-native.mts"
-    );
+    const hasBrowserVariant = this.project.getSourceFile(basePath + "-browser.mts");
+    const hasReactNativeVariant = this.project.getSourceFile(basePath + "-react-native.mts");
     if (!hasBrowserVariant && !hasReactNativeVariant) return undefined;
     const relativePath = filePath.substring(srcIndex + "/src/".length);
     return "#platform/" + relativePath.replace(/\.ts$/, "");
@@ -255,23 +217,14 @@ class BinderImp implements Binder {
       [unknown, DeclarationInfo | StaticHelperMetadata]
     >();
     for (const [key, value] of this.declarations) {
-      declarationByPlaceholder.set(this.serializePlaceholder(key), [
-        key,
-        value
-      ]);
+      declarationByPlaceholder.set(this.serializePlaceholder(key), [key, value]);
     }
     for (const [key, value] of this.staticHelpers) {
-      declarationByPlaceholder.set(this.serializePlaceholder(key), [
-        key,
-        value
-      ]);
+      declarationByPlaceholder.set(this.serializePlaceholder(key), [key, value]);
     }
     const dependencyByPlaceholder = new Map<string, ReferenceableSymbol>();
     for (const dependency of Object.values(this.dependencies)) {
-      dependencyByPlaceholder.set(
-        this.serializePlaceholder(refkey(dependency)),
-        dependency
-      );
+      dependencyByPlaceholder.set(this.serializePlaceholder(refkey(dependency)), dependency);
     }
 
     this.project.getSourceFiles().map((file) => {
@@ -285,13 +238,13 @@ class BinderImp implements Binder {
           file,
           declarationByPlaceholder,
           presentPlaceholders,
-          replacementMap
+          replacementMap,
         );
         this.resolveDependencyReferences(
           file,
           dependencyByPlaceholder,
           presentPlaceholders,
-          replacementMap
+          replacementMap,
         );
         if (replacementMap.size > 0) {
           applyReplacements(file, replacementMap);
@@ -300,9 +253,7 @@ class BinderImp implements Binder {
       const importStructures = this.imports.get(file);
       if (importStructures && importStructures.length > 0) {
         // Sort imports in place by module specifier to ensure consistent ordering
-        importStructures.sort((a, b) =>
-          a.moduleSpecifier < b.moduleSpecifier ? -1 : 1
-        );
+        importStructures.sort((a, b) => (a.moduleSpecifier < b.moduleSpecifier ? -1 : 1));
         file.addImportDeclarations(importStructures);
       }
     });
@@ -322,7 +273,7 @@ class BinderImp implements Binder {
     file: SourceFile,
     dependencyByPlaceholder: Map<string, ReferenceableSymbol>,
     presentPlaceholders: Set<string>,
-    replacementMap: Map<string, string>
+    replacementMap: Map<string, string>,
   ) {
     for (const [placeholder, dependency] of dependencyByPlaceholder) {
       if (!presentPlaceholders.has(placeholder)) {
@@ -346,17 +297,11 @@ class BinderImp implements Binder {
    */
   private resolveDeclarationReferences(
     file: SourceFile,
-    declarationByPlaceholder: Map<
-      string,
-      [unknown, DeclarationInfo | StaticHelperMetadata]
-    >,
+    declarationByPlaceholder: Map<string, [unknown, DeclarationInfo | StaticHelperMetadata]>,
     presentPlaceholders: Set<string>,
-    replacementMap: Map<string, string>
+    replacementMap: Map<string, string>,
   ) {
-    for (const [
-      placeholderKey,
-      [declarationKey, declaration]
-    ] of declarationByPlaceholder) {
+    for (const [placeholderKey, [declarationKey, declaration]] of declarationByPlaceholder) {
       if (!presentPlaceholders.has(placeholderKey)) {
         continue;
       }
@@ -373,9 +318,7 @@ class BinderImp implements Binder {
       if (file !== declarationSourceFile) {
         this.trackReference(declarationKey, file);
         // Use #platform/ subpath import specifier for static helpers in warp packages
-        const platformSpecifier = this.getPlatformImportSpecifier(
-          declarationSourceFile
-        );
+        const platformSpecifier = this.getPlatformImportSpecifier(declarationSourceFile);
         const importTarget = platformSpecifier ?? declarationSourceFile;
         const importDec = this.addImport(file, importTarget, name);
         name = importDec.alias ?? name;
@@ -399,7 +342,7 @@ class BinderImp implements Binder {
       if (!sourceFile) {
         // This should be unreachable
         throw new Error(
-          `Static helper ${helper.name} does not have a source file. Make sure that loadStaticHelpers has been correctly initialized in index.ts`
+          `Static helper ${helper.name} does not have a source file. Make sure that loadStaticHelpers has been correctly initialized in index.ts`,
         );
       }
       const referencedHelper = this.references.get(refkey(helper));
@@ -411,11 +354,9 @@ class BinderImp implements Binder {
 
     // Also keep files that are imported by any used helper file
     const helperFiles = this.project.getSourceFiles(
-      normalizePath(path.join(sourceRoot, "static-helpers/**/*.*ts"))
-    );
-    const usedFiles = helperFiles.filter(
-      (file) => !isFileUnused(file, usedHelperNames)
+      normalizePath(path.join(sourceRoot, "static-helpers/**/*.*ts")),
     );
+    const usedFiles = helperFiles.filter((file) => !isFileUnused(file, usedHelperNames));
     for (const usedFile of usedFiles) {
       for (const importDecl of usedFile.getImportDeclarations()) {
         const resolved = importDecl.getModuleSpecifierSourceFile();
@@ -437,19 +378,14 @@ class BinderImp implements Binder {
     }
     this.project
       //normalizae the final path to adapt to different systems
-      .getSourceFiles(
-        normalizePath(path.join(testRoot, "test/generated/util/**/*.*ts"))
-      )
+      .getSourceFiles(normalizePath(path.join(testRoot, "test/generated/util/**/*.*ts")))
       .filter((file) => isFileUnused(file, usedHelperNames))
       .forEach((helperFile) => helperFile.delete());
   }
 }
 
 // Provide the binder context to be used globally
-export function provideBinder(
-  project: Project,
-  options: BinderOptions = {}
-): Binder {
+export function provideBinder(project: Project, options: BinderOptions = {}): Binder {
   const binder = new BinderImp(project, options);
   provideContext("binder", binder);
   return binder;
@@ -460,7 +396,7 @@ function isFileUnused(file: SourceFile, usedHelperNames: string[]) {
   // A file is used if it matches a used helper name exactly,
   // or is a platform-specific variant (e.g. "foo-browser" for helper "foo")
   return !usedHelperNames.some(
-    (s) => name === s || name === `${s}-browser` || name === `${s}-react-native`
+    (s) => name === s || name === `${s}-browser` || name === `${s}-react-native`,
   );
 }
 
@@ -478,18 +414,12 @@ export function useBinder(): Binder {
  * @param sourceFile - The source file to mutate.
  * @param replacementMap - A map from each placeholder string to its replacement value.
  */
-function applyReplacements(
-  sourceFile: SourceFile,
-  replacementMap: Map<string, string>
-): void {
+function applyReplacements(sourceFile: SourceFile, replacementMap: Map<string, string>): void {
   if (replacementMap.size === 0) {
     return;
   }
   const text = sourceFile.getFullText();
-  const placeholderRegex = new RegExp(
-    `${escapeRegExp(PLACEHOLDER_PREFIX)}.+?__`,
-    "g"
-  );
+  const placeholderRegex = new RegExp(`${escapeRegExp(PLACEHOLDER_PREFIX)}.+?__`, "g");
   let changed = false;
   const updatedText = text.replace(placeholderRegex, (match) => {
     const replacement = replacementMap.get(match);
@@ -517,10 +447,7 @@ function collectPlaceholders(sourceFile: SourceFile): Set<string> {
     return result;
   }
   // Refkeys are alphanumeric (see refkey.ts), so `.+?` safely stops at `__`.
-  const placeholderRegex = new RegExp(
-    `${escapeRegExp(PLACEHOLDER_PREFIX)}.+?__`,
-    "g"
-  );
+  const placeholderRegex = new RegExp(`${escapeRegExp(PLACEHOLDER_PREFIX)}.+?__`, "g");
   let match: RegExpExecArray | null;
   while ((match = placeholderRegex.exec(text)) !== null) {
     result.add(match[0]);

package/src/framework/hooks/sdk-types.ts

@@ -0,0 +1,219 @@
+import {
+  SdkClientType,
+  SdkHttpOperation,
+  SdkModelPropertyType,
+  SdkModelType,
+  SdkServiceMethod,
+  SdkType,
+  getClientType,
+} from "@azure-tools/typespec-client-generator-core";
+import { Operation, Type, getNamespaceFullName } from "@typespec/compiler";
+import { provideContext, useContext } from "../../context-manager.js";
+
+import { reportDiagnostic } from "../../lib.js";
+import { visitPackageTypes } from "../../modular/emit-models.js";
+import { getAllAncestors, getAllProperties } from "../../modular/helpers/operation-helpers.js";
+import { normalizeModelPropertyName } from "../../modular/type-expressions/get-type-expression.js";
+import { NameType, normalizeName } from "../../rlc-common/index.js";
+import { SdkContext } from "../../utils/interfaces.js";
+
+export const emitQueue: Set<SdkType> = new Set<SdkType>();
+export const flattenPropertyModelMap: Map<SdkModelPropertyType, SdkModelType> = new Map<
+  SdkModelPropertyType,
+  SdkModelType
+>();
+/**
+ * Set of paged result models that should keep their public name (no "_" prefix).
+ * This includes models used as non-paging method responses or as model properties.
+ * Precomputed during visitPackageTypes for O(1) lookups in normalizeModelName.
+ */
+export const pagedModelsKeptPublic = new Set<SdkType>();
+
+export interface SdkTypeContext {
+  operations: Map<Type, SdkServiceMethod<SdkHttpOperation>>;
+  types: Map<Type, SdkType>;
+  flattenProperties: Map<SdkModelPropertyType, SdkFlattenPropertyContext>;
+}
+
+export interface SdkFlattenPropertyContext {
+  baseModel: SdkModelType;
+  conflictMap?: Map<SdkModelPropertyType, string>;
+}
+
+export function useSdkTypes() {
+  const sdkTypesContext = useContext("sdkTypes");
+  const { tcgcContext } = useContext("emitContext");
+
+  function getSdkType(type: Operation): SdkServiceMethod<SdkHttpOperation>;
+  function getSdkType(type: Type): SdkType;
+  function getSdkType(type: Type | Operation): SdkType | SdkServiceMethod<SdkHttpOperation> {
+    let sdkType: SdkType | SdkServiceMethod<SdkHttpOperation> | undefined;
+
+    if (type.kind === "Operation") {
+      sdkType = sdkTypesContext.operations.get(type);
+    } else {
+      sdkType = sdkTypesContext.types.get(type) ?? getClientType(tcgcContext, type);
+    }
+
+    if (!sdkType) {
+      throw new Error(
+        `SdkType not found for type: ${type.kind} ${
+          "name" in type && typeof type.name === "string" ? type.name : ""
+        } ${
+          "namespace" in type && type.namespace ? ` in ${getNamespaceFullName(type.namespace)}` : ""
+        }`,
+      );
+    }
+
+    return sdkType;
+  }
+
+  return getSdkType;
+}
+
+export function provideSdkTypes(context: SdkContext) {
+  const { sdkPackage } = context;
+  const sdkTypesContext: SdkTypeContext = {
+    operations: new Map<Type, SdkServiceMethod<SdkHttpOperation>>(),
+    types: new Map<Type, SdkType>(),
+    flattenProperties: new Map<SdkModelPropertyType, SdkFlattenPropertyContext>(),
+  };
+  visitPackageTypes(context);
+  enrichFlattenProperties(context, sdkTypesContext.flattenProperties, flattenPropertyModelMap);
+  for (const sdkModel of emitQueue) {
+    switch (sdkModel.kind) {
+      case "model":
+        sdkModel.properties.forEach((prop) => {
+          sdkTypesContext.types.set(prop.type.__raw!, prop.type);
+        });
+        if (sdkModel.discriminatedSubtypes) {
+          Object.values(sdkModel.discriminatedSubtypes).forEach((subtype) => {
+            sdkTypesContext.types.set(subtype.__raw!, subtype);
+          });
+        }
+        break;
+      case "enum":
+        if (sdkModel.__raw) {
+          sdkTypesContext.types.set(sdkModel.__raw, sdkModel);
+        }
+        break;
+      case "union":
+        sdkModel.variantTypes.forEach((v) => {
+          if (v.__raw) {
+            sdkTypesContext.types.set(v.__raw, v);
+          }
+        });
+        break;
+      case "array":
+        sdkTypesContext.types.set(sdkModel.valueType.__raw!, sdkModel.valueType);
+        break;
+      case "dict":
+        sdkTypesContext.types.set(sdkModel.valueType.__raw!, sdkModel.valueType);
+        break;
+      case "nullable":
+        sdkTypesContext.types.set(sdkModel.__raw!, sdkModel);
+        sdkTypesContext.types.set(sdkModel.type.__raw!, sdkModel.type);
+        break;
+    }
+    if (!sdkModel.__raw) {
+      continue;
+    }
+    sdkTypesContext.types.set(sdkModel.__raw, sdkModel);
+  }
+
+  for (const client of sdkPackage.clients) {
+    for (const method of getAllOperationsFromClient(client)) {
+      if (!method.__raw) {
+        continue;
+      }
+
+      sdkTypesContext.operations.set(method.__raw, method);
+
+      // Visit the parameters of the method to add them to the types map
+      method.parameters.forEach((param) => {
+        sdkTypesContext.types.set(param.type.__raw!, param.type);
+      });
+    }
+  }
+
+  provideContext("sdkTypes", sdkTypesContext);
+}
+
+// Enrich flatten properties with their base models and conflict maps
+function enrichFlattenProperties(
+  context: SdkContext,
+  propertyContextMap: Map<SdkModelPropertyType, SdkFlattenPropertyContext>,
+  propertyModelMap: Map<SdkModelPropertyType, SdkModelType>,
+) {
+  // Build a map of base model to its existing properties excluding flatten properties
+  // To check for conflicts later
+  const baseModelProperties = new Map<SdkModelType, Set<string>>();
+  propertyModelMap.forEach((baseModel, _) => {
+    if (!baseModelProperties.has(baseModel)) {
+      const propertiesExcludedFlatten = getAllProperties(
+        context,
+        baseModel,
+        getAllAncestors(baseModel),
+      )
+        .filter((p) => !(p.flatten && p.type.kind === "model"))
+        .map((p) => normalizeModelPropertyName(context, p));
+      baseModelProperties.set(baseModel, new Set<string>(propertiesExcludedFlatten));
+    }
+  });
+  for (const [flattenProperty, baseModel] of propertyModelMap) {
+    const flattenContext: SdkFlattenPropertyContext = {
+      baseModel: baseModel,
+    };
+    propertyContextMap.set(flattenProperty, flattenContext);
+    const existingProperties = baseModelProperties.get(baseModel)!;
+    const conflictMap = new Map<SdkModelPropertyType, string>();
+    const flattenModel = flattenProperty.type;
+
+    if (baseModelProperties.has(flattenModel as SdkModelType)) {
+      // If the flatten model is also a base model of other flatten properties, which means it has multiple consecutive flatten operations
+      // Since we cannot handle the flatten transition, report warning and skip it for now
+      reportDiagnostic(context.program, {
+        code: "unsupported-flatten-transition",
+        format: {
+          propertyName: flattenProperty.name,
+          modelName: baseModel.name,
+        },
+        target: flattenProperty.__raw!,
+      });
+    }
+    const allFlattenProperties = getAllProperties(
+      context,
+      flattenModel,
+      getAllAncestors(flattenModel),
+    );
+    for (const flattenChildProperty of allFlattenProperties) {
+      let childPropertyName = normalizeModelPropertyName(context, flattenChildProperty);
+      if (existingProperties.has(childPropertyName)) {
+        childPropertyName = normalizeName(
+          `${childPropertyName}_${flattenProperty.name}_${childPropertyName}`,
+          NameType.Property,
+        );
+        conflictMap.set(flattenChildProperty, childPropertyName);
+      }
+      existingProperties.add(childPropertyName);
+    }
+    if (conflictMap.size === 0) {
+      continue;
+    }
+    flattenContext.conflictMap = conflictMap;
+  }
+}
+
+export function getAllOperationsFromClient(client: SdkClientType<SdkHttpOperation>) {
+  const clientQueue = [client];
+  const operations: SdkServiceMethod<SdkHttpOperation>[] = [];
+  while (clientQueue.length > 0) {
+    const client = clientQueue.pop()!;
+    if (client.children) {
+      clientQueue.push(...client.children);
+    }
+    operations.push(...client.methods);
+  }
+
+  return operations;
+}

package/src/framework/hooks/use-dependencies.ts

@@ -0,0 +1,16 @@
+import { provideContext, useContext } from "../../context-manager.js";
+import { DefaultCoreDependencies } from "../../modular/external-dependencies.js";
+import { ExternalDependencies } from "../dependency.js";
+
+export function provideDependencies(customDependencies: Partial<ExternalDependencies> = {}) {
+  const dependencies = {
+    ...DefaultCoreDependencies,
+    ...customDependencies,
+  } as ExternalDependencies;
+
+  provideContext("dependencies", dependencies);
+}
+
+export function useDependencies(): ExternalDependencies {
+  return useContext("dependencies");
+}