@arcgis/core-adapter 4.32.0-next.5 → 4.32.0-next.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/core-adapter",
-  "version": "4.32.0-next.5",
+  "version": "4.32.0-next.50",
   "description": "ArcGIS Core Adapter",
   "type": "module",
   "main": "dist/index.cjs",
@@ -13,35 +13,11 @@
       "require": "./dist/index.cjs"
     }
   },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
-    "access": "public"
-  },
   "license": "SEE LICENSE IN LICENSE.md",
-  "scripts": {
-    "build": "yarn pre:build && yarn build:generate && yarn build:tsup",
-    "build:dev": "yarn build",
-    "build:generate": "tsx ./scripts/generator.ts",
-    "build:tsup": "tsup --silent",
-    "pre:build": "rimraf ./src/index.ts",
-    "clean": "rimraf .turbo ./dist",
-    "update-types": "tsx ./scripts/update-adapter-typings"
-  },
   "dependencies": {
     "tslib": "^2.7.0"
   },
-  "devDependencies": {
-    "@arcgis/typescript-config": "4.32.0-next.5",
-    "@types/node": "^20.2.5",
-    "resolve-pkg": "^2.0.0",
-    "rimraf": "^5.0.0",
-    "ts-morph": "^22.0.0",
-    "tsup": "^8.3.0",
-    "tsx": "^4.19.0",
-    "typescript": "~5.4.0"
-  },
   "peerDependencies": {
-    "@arcgis/core": ">=4.31.0-next <4.32"
-  },
-  "gitHead": "e4e69443c65b6667007b81e8a05805bec146db56"
-}
+    "@arcgis/core": ">=4.32.0-next <4.33"
+  }
+}

package/scripts/generator.ts

@@ -1,12 +1,12 @@
 import fs from "fs";
 import path from "path";
-import ts from "typescript";
 import resolvePkg from "resolve-pkg";
 import type { SourceFile } from "ts-morph";
 import { Project } from "ts-morph";
-import { fileURLToPath } from "url";
+import ts from "typescript";
+import { publicModules } from "../support/publicModules";
 
-const dirname = path.dirname(fileURLToPath(import.meta.url));
+const dirname = import.meta.dirname;
 
 /**
  * Collect the details of a type we are interested in
@@ -53,8 +53,9 @@ const nativeGenericTypes = nativeTypes.map((x) => `<${x}>`);
 
 // Modules to ignore
 const ignoreExports: string[] = [
-  // declared as a namespace
+  // virtual
   "esri/core/units",
+  "esri/core/quantity",
 ];
 
 // Module that returns an instance of a class
@@ -165,6 +166,8 @@ function generate(): void {
 
   const publicTypeValidator = new PublicTypeValidator();
 
+  const visitedModules = new Set<string>();
+
   // We will visit the typings and extract the symbols we need
   // Add the singletons to the typeInfos array
   const typeInfos: TypeInfo[] = [...singletons.entries()].map(([amdModulePath, typeName]) => ({
@@ -189,10 +192,24 @@ function generate(): void {
       // Only include imports that are in the import dictionary
       // or are part of "esri/applications" modules
       const amdModulePath = node.name.text;
+      if (visitedModules.has(amdModulePath)) {
+        console.log("\x1b[33m", "WARNING: Skipping duplicate module: ", amdModulePath);
+        return node;
+      }
+      visitedModules.add(amdModulePath);
       if (!amdImportReferencesKeys.includes(amdModulePath) && !amdModulePath.includes("esri/applications")) {
         return node;
       }
 
+      if (amdModulePath.includes("esri/applications") && !publicModules.includes(amdModulePath)) {
+        console.log(
+          "\x1b[33m",
+          "WARNING: Skipping, application module not in publicModules file in js-api repo: ",
+          amdModulePath,
+        );
+        return node;
+      }
+
       // Ignore modules that are in the ignore list and the singletons that are already in the typeInfos array
       if (ignoreModule(amdModulePath) || singletons.has(amdModulePath)) {
         return node;
@@ -377,7 +394,22 @@ function processUnionType(parameterInfo: ParameterInfo): string {
 function generateImportFunction(entry: TypeInfo): string {
   const { amdModulePath, esmModulePath, typeName, instanceType = false } = entry;
   const functionNameSuffix = convertToPascalCase(amdModulePath);
-  const promiseType = instanceType ? typeName : `typeof ${typeName}`;
+  const resolvedTypeName = [
+    "__esri.CollectionFlattener",
+    "__esri.SelectionOperation",
+    "__esri.SketchTooltipControls",
+  ].includes(typeName)
+    ? "any"
+    : typeName;
+
+  let promiseType: string;
+  if (resolvedTypeName === "any") {
+    promiseType = "any";
+  } else if (instanceType) {
+    promiseType = resolvedTypeName;
+  } else {
+    promiseType = `typeof ${resolvedTypeName}`;
+  }
 
   return `
 export async function import${functionNameSuffix}(): Promise<${promiseType}> {

package/scripts/update-adapter-typings.ts

@@ -1,5 +1,5 @@
-import fs from "fs";
-import https from "https";
+import fs from "node:fs";
+import https from "node:https";
 import resolvePkg from "resolve-pkg";
 
 // Get the @arcgis/core installed version
@@ -22,37 +22,71 @@ const files = [
     source: `https://jsapi.esri.com/typings/api-reference-esm-imports-${coreVersion}.json`,
     destination: `${process.cwd()}/support/api-reference-esm-imports.json`,
   },
+  {
+    source: "https://raw.devtopia.esri.com/WebGIS/arcgis-js-api/4master/build/publicModules.mjs",
+    destination: `${process.cwd()}/support/publicModules.ts`,
+  },
 ];
 
+const HttpOK = 200;
+
 // Download the typings and support files.
 async function downloadSupportFiles(source: string, destination: string): Promise<void> {
-  try {
-    fs.unlinkSync(destination);
-  } catch {
-    console.log("Error in deleting typings files, continue...");
-  }
-
-  const file = fs.createWriteStream(destination);
-
   await new Promise((resolve, reject) => {
-    https.get(source, (resp) => {
+    const isPublicModules = source.includes("publicModules.mjs");
+    const options: {
+      headers?: {
+        Authorization: string;
+      };
+    } = {};
+    if (isPublicModules) {
+      options.headers = {
+        Authorization: `Token ${process.env.DEVTOPIA_TOKEN}`,
+      };
+    }
+    https.get(source, options, (resp) => {
+      const file = resp.statusCode === HttpOK ? fs.createWriteStream(destination) : undefined;
       console.log("Downloaded:", source);
       console.log(`Response type: ${resp.headers["content-type"]}`);
 
-      resp.pipe(file);
+      if (resp.statusCode !== HttpOK) {
+        console.error(`Request failed for ${source}:`, resp.statusMessage);
+        console.error(`Skipping: ${destination}`);
+        file?.close();
+        resolve(undefined);
+      }
+
+      if (isPublicModules) {
+        let body = "";
+        resp.on("data", (chunk) => {
+          body += chunk;
+        });
+
+        resp.on("end", () => {
+          const regex = /const\s+publicModules\s*=\s*\[(.*?)\];/su;
+          const match = body.match(regex);
+          if (match) {
+            const publicModules = match[1];
+            body = `export const publicModules = [${publicModules}];`;
+            file?.write(body);
+          }
+        });
+      } else {
+        resp.pipe(file!);
+      }
 
       resp.on("error", (err) => {
         console.error(`Request error for ${source}:`, err);
         reject(err);
       });
 
-      file.on("error", (err) => {
+      file?.on("error", (err) => {
         console.error(`Writing error for ${destination}:`, err);
         reject(err);
       });
 
-      file.on("finish", () => {
-        file.close();
+      file?.on("finish", () => {
+        file?.close();
         resolve(undefined);
       });
     });