@arcgis/core-adapter 4.32.0-next.8 → 4.32.0-next.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/core-adapter",
-  "version": "4.32.0-next.8",
+  "version": "4.32.0-next.81",
   "description": "ArcGIS Core Adapter",
   "type": "module",
   "main": "dist/index.cjs",
@@ -13,6 +13,9 @@
       "require": "./dist/index.cjs"
     }
   },
+  "files": [
+    "dist/"
+  ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
     "tslib": "^2.7.0"

package/.turbo/turbo-build.log

@@ -1,3 +0,0 @@
-Reading typings file...
-Modules converted to core-adapter:  946
-Adapter file generated.

package/scripts/generator.ts

@@ -1,419 +0,0 @@
-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";
-
-const dirname = path.dirname(fileURLToPath(import.meta.url));
-
-/**
- * Collect the details of a type we are interested in
- */
-interface TypeInfo {
-  // The path of the module that contains the type. For example: `esri/identity/IdentityManager`
-  amdModulePath: string;
-  // The path of the module that contains the type. For example: `@arcgis/core/identity/IdentityManager`
-  esmModulePath?: string;
-  // The name of the type. For example: `__esri.Credential`
-  typeName: string;
-  // If the type is a class and has at least one constructor, we collect the parameters of the constructor
-  constructorParameters?: ParameterInfo[];
-  // If the type is a singleton then instanceType will be true
-  instanceType?: boolean;
-}
-
-/**
- * Describe a parameter of a constructor
- */
-interface ParameterInfo {
-  // The name of the parameter
-  name: string;
-  // The type of the parameter
-  type: string;
-}
-
-const nativeTypes: string[] = [
-  "number",
-  "string",
-  "boolean",
-  "null",
-  "undefined",
-  "object",
-  "symbol",
-  "any",
-  "void",
-  "never",
-  "array",
-];
-
-const nativeArrayTypes = nativeTypes.map((x) => `${x}[]`);
-const nativeGenericTypes = nativeTypes.map((x) => `<${x}>`);
-
-// Modules to ignore
-const ignoreExports: string[] = [
-  // declared as a namespace
-  "esri/core/units",
-];
-
-// Module that returns an instance of a class
-const singletons = new Map<string, string>([["esri/identity/IdentityManager", "__esri.IdentityManager"]]);
-
-// The header of the index file
-// We want to detect if the environment is AMD
-// Define the AMD import module global
-const indexHeader = `
-const isAMD = typeof window !== "undefined" && "$arcgis" in window && typeof window.$arcgis === "object" && "import" in window.$arcgis && !("forceESM" in window.$arcgis);
-
-declare global {
-  interface Window {
-    $arcgis: { import: <T>(modules: string | string[], forceESM?: boolean) => Promise<T> };
-  }
-}
-
-interface DefaultModule<T> {
-  default: T;
-}
-
-
-function isDefaultModule<T>(module: DefaultModule<T> | T): module is DefaultModule<T> {
-  return (module as DefaultModule<T>).default !== undefined;
-}
-
-/**
- * Load an undocumented module respecting the current environment (AMD or ESM).
- * The module type will certainly be \`any\` as it is not documented.
- * For ESM, if the module exports a default, it will be returned, otherwise the module itself will be returned.
- * @param modulePath - The path to the module to load, example: "@arcgis/core/Map"
- * @param deferredImport - A function that should call import() and return the module, example: () => import("@arcgis/core/Map")
- * @returns - Promise that resolves to the module
- */
-export async function loadUndocumentedModule<T>(modulePath: string, deferredImport: () => Promise<T>): Promise<T> {
-  if (isAMD) {
-    return await window.$arcgis.import(modulePath);
-  }
-  const module = deferredImport();
-  return isDefaultModule(module) ? module.default : module;
-}
-`;
-
-class PublicTypeValidator {
-  project: Project;
-  source: SourceFile | undefined;
-
-  constructor() {
-    this.project = new Project();
-    const coreInterfacesPath = resolvePkg("@arcgis/core/interfaces.d.ts");
-    if (!coreInterfacesPath) {
-      console.error("Could not find @arcgis/core/interfaces.d.ts. Make sure you have installed @arcgis/core.");
-      return;
-    }
-
-    this.source = this.project.addSourceFileAtPath(coreInterfacesPath);
-  }
-
-  validateType(typeName: string): boolean {
-    if (!this.source) {
-      return false;
-    }
-
-    const [namespaceName, name] = typeName.split(".");
-    const namespace = this.source.getModule(namespaceName);
-    if (!namespace) {
-      return false;
-    }
-
-    // Under the namespace `__esri`, we can find type as class, interface or namespace
-    // ```
-    // declare namespace __esri {
-    //   export interface Credential { ... }
-    //   export class Credential { ... }
-    //   namespace geometry { ... }
-    // }
-    // ```
-    return !!namespace.getClass(name) || !!namespace.getInterface(name) || !!namespace.getModule(name);
-  }
-}
-
-function generate(): void {
-  console.log("Reading typings file...");
-
-  // Load our esm import references
-  const esmImportReferencesContent: string = fs.readFileSync(
-    path.join(dirname, "../support/api-reference-esm-imports.json"),
-    "utf8",
-  );
-  const amdImportReferences = JSON.parse(esmImportReferencesContent) as Record<string, string>;
-  const amdImportReferencesKeys = Object.keys(amdImportReferences);
-
-  // Start building the index file
-  // At the top we add the amd logic
-  const indexFileStatements: string[] = [];
-  indexFileStatements.push(indexHeader);
-
-  // Create a ts program with the typings file
-  // Also create a type checker
-  const typingsFilepath = path.resolve(dirname, "../support/arcgis.d.ts");
-  const program = ts.createProgram([typingsFilepath], {});
-  const checker = program.getTypeChecker();
-  const typingsProgram = program.getSourceFile(typingsFilepath);
-  if (!typingsProgram) {
-    console.error(`Could not find source file: ${typingsFilepath}`);
-    return;
-  }
-
-  const publicTypeValidator = new PublicTypeValidator();
-
-  // 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]) => ({
-    amdModulePath,
-    esmModulePath: convertAmdToEsmPath(amdModulePath),
-    typeName,
-    instanceType: true,
-  }));
-
-  /** Create a visitor function for the context */
-  function createVisitor(context: ts.TransformationContext): ts.Visitor<ts.Node, ts.Node> {
-    return function visit(node: ts.Node): ts.Node {
-      // Visit each child node
-      node = ts.visitEachChild(node, visit, context);
-
-      // We are only interested in module declarations
-      // Example: `declare module "esri/identity/IdentityManager" {`
-      if (!ts.isModuleDeclaration(node)) {
-        return node;
-      }
-
-      // Only include imports that are in the import dictionary
-      // or are part of "esri/applications" modules
-      const amdModulePath = node.name.text;
-      if (!amdImportReferencesKeys.includes(amdModulePath) && !amdModulePath.includes("esri/applications")) {
-        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;
-      }
-
-      // Loop thru the module body
-      node.body?.forEachChild((statement) => {
-        // We are only interested in import equals declarations inside ModuleDeclarations
-        // For example:
-        // declare module "esri/identity/Credential" {
-        //   import Credential = __esri.Credential;  << This is what we are interested in
-        //   export = Credential;
-        // }
-        if (!ts.isImportEqualsDeclaration(statement)) {
-          return;
-        }
-
-        // Get the type name, i.g. `__esri.Credential` and validate that it is a class or interface
-        // in the public interfaces.
-        const typeName = statement.moduleReference.getText(typingsProgram);
-        if (!publicTypeValidator.validateType(typeName)) {
-          return;
-        }
-
-        // Validate that we can find the esm module file
-        const esmModulePath = convertAmdToEsmPath(amdModulePath);
-        const resolvedEsmModulePath = resolvePkg(esmModulePath);
-        if (!resolvedEsmModulePath || !fs.existsSync(resolvedEsmModulePath)) {
-          console.error(`Could not find esm module for: ${esmModulePath}`);
-          return;
-        }
-
-        // If the type has a constructor, we want to extract the parameters
-        // to inject the new function
-        const constructorParameters = extractConstructorParameters(statement);
-
-        // Get the symbol and extract details
-        typeInfos.push({ amdModulePath, esmModulePath, typeName, constructorParameters });
-      });
-
-      return node;
-    };
-  }
-
-  /** This is our entry point for the transformer */
-  function extractTypeInfos(context: ts.TransformationContext): ts.Transformer<ts.Node> {
-    const visit = createVisitor(context);
-    return (node: ts.Node) => ts.visitNode(node, visit);
-  }
-
-  /** Serialize a class symbol information */
-  function extractConstructorParameters(statement: ts.ImportEqualsDeclaration): ParameterInfo[] | undefined {
-    // Get the symbol of the module reference
-    // Example: `import Credential = __esri.Credential;`
-    // In this example, `__esri.Credential` is the module reference
-    // We want to get the type of `__esri.Credential`
-    const symbol = checker.getSymbolAtLocation(statement.moduleReference);
-    if (!symbol) {
-      throw new Error("Symbol not found");
-    }
-
-    // The constructor parameters are only relevant if the type has a constructor signature.
-    // We want to extract the constructor parameters for the first constructor signature.
-    // Example: `declare class Credential { constructor(properties: CredentialProperties); }`
-    // constructorParameters will be an array with one item: `{ name: "properties", type: "CredentialProperties" }` or undefined.
-    return checker
-      .getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration!)
-      .getConstructSignatures()
-      .at(0)
-      ?.getParameters()
-      .map<ParameterInfo>((parameterSymbol: ts.Symbol) => ({
-        name: parameterSymbol.getName(),
-        type: checker.typeToString(
-          checker.getTypeOfSymbolAtLocation(parameterSymbol, parameterSymbol.valueDeclaration!),
-        ),
-      }));
-  }
-
-  // Use the transformer to visit the typings file
-  ts.transform(typingsProgram, [extractTypeInfos]);
-
-  // At this point the typeInfos array contains all the symbols we are interested in
-  for (const typeInfo of typeInfos) {
-    // Generate the import function
-    indexFileStatements.push(generateImportFunction(typeInfo));
-
-    // If we have constructor parameters, generate the new function
-    if (typeInfo.constructorParameters) {
-      indexFileStatements.push(generateNewFunction(typeInfo));
-    }
-  }
-
-  console.log("Modules converted to core-adapter: ", typeInfos.length);
-
-  const indexContent = indexFileStatements.join("\n");
-  fs.writeFile("src/index.ts", indexContent, (err) => {
-    if (err) {
-      console.error("Error generating adapter file:", err);
-    } else {
-      console.log("Adapter file generated.");
-    }
-  });
-}
-
-function generateNewFunction(entry: TypeInfo): string {
-  const { amdModulePath, typeName, constructorParameters } = entry;
-  if (!constructorParameters) {
-    throw new Error("Constructor parameters are required");
-  }
-
-  const functionNameSuffix = convertToPascalCase(amdModulePath);
-
-  // Generate the parameters declarations and the call arguments
-  const parameterDeclarations: string[] = [];
-  const callArgumentsParts: string[] = [];
-  for (const parameterInfo of constructorParameters) {
-    callArgumentsParts.push(parameterInfo.name);
-
-    // Do we have a union type?
-    if (parameterInfo.type.includes("|")) {
-      parameterDeclarations.push(processUnionType(parameterInfo));
-      continue;
-    }
-
-    // Do we have a native type?
-    if (nativeTypes.some((x) => x.includes(parameterInfo.type || ""))) {
-      parameterDeclarations.push(`${parameterInfo.name}: ${parameterInfo.type}`);
-      continue;
-    }
-
-    // Must be an esri type
-    parameterDeclarations.push(`${parameterInfo.name}: __esri.${parameterInfo.type}`);
-  }
-
-  const parametersDeclaration = parameterDeclarations.join(", ");
-  const callArguments = callArgumentsParts.join(", ");
-
-  return `
-export async function new${functionNameSuffix}(${parametersDeclaration}): Promise<${typeName}> {
-  const ModConstructor = await import${functionNameSuffix}();
-  return new ModConstructor(${callArguments});
-}`;
-}
-
-/**
- * Process a parameter defined as a union type
- */
-function processUnionType(parameterInfo: ParameterInfo): string {
-  // Split the union type into parts and process each part
-  const unionedTypesParts = parameterInfo.type.split("|");
-  const correctedUnionedTypes: string[] = [];
-  for (const unionTypesPart of unionedTypesParts) {
-    // Is the part a native type?
-    if (nativeArrayTypes.some((x) => unionTypesPart.includes(x))) {
-      correctedUnionedTypes.push(unionTypesPart);
-      continue;
-    }
-
-    // Is the part a Collection type?
-    if (unionTypesPart.includes("Collection<")) {
-      // Handle Collection types
-      if (nativeGenericTypes.some((x) => unionTypesPart.includes(x))) {
-        correctedUnionedTypes.push(`__esri.${unionTypesPart.trim()}`);
-      } else {
-        const v = unionTypesPart.replace(/<(?<esriTypeName>[^>]+)>/gu, "<__esri.$1>");
-        correctedUnionedTypes.push(`__esri.${v.trim()}`);
-      }
-      continue;
-    }
-
-    // Must be an esri type
-    correctedUnionedTypes.push(`__esri.${unionTypesPart.trim()}`);
-  }
-
-  // Re-assemble the unioned types
-  return `${parameterInfo.name}: ${correctedUnionedTypes.join(" | ")}`;
-}
-
-/**
- * Generate the normal import function
- */
-function generateImportFunction(entry: TypeInfo): string {
-  const { amdModulePath, esmModulePath, typeName, instanceType = false } = entry;
-  const functionNameSuffix = convertToPascalCase(amdModulePath);
-  const promiseType = instanceType ? typeName : `typeof ${typeName}`;
-
-  return `
-export async function import${functionNameSuffix}(): Promise<${promiseType}> {
-  if (isAMD) {
-    return await window.$arcgis.import("${amdModulePath}");
-  }
-  const module = await import("${esmModulePath}");
-  return isDefaultModule(module) ? module.default : module;
-}`;
-}
-
-function upperFirst(s: string): string {
-  return s[0].toUpperCase() + s.slice(1);
-}
-
-function ignoreModule(s: string): boolean {
-  return ignoreExports.includes(s);
-}
-
-/**
- * Convert a module path to a pascal case name without the `esri/` prefix.
- * For example: `esri/identity/IdentityManager` becomes `IdentityIdentityManager`
- */
-function convertToPascalCase(input: string): string {
-  // Split the string by slashes and remove any empty strings
-  const parts = input.replace("esri/", "").split("/").filter(Boolean);
-
-  // Capitalize the first letter of each part
-  const pascalCaseParts = parts.map(upperFirst);
-
-  // Join the parts together
-  return pascalCaseParts.join("");
-}
-
-function convertAmdToEsmPath(amdPath: string): string {
-  return amdPath.replace("esri/", "@arcgis/core/").replace(/(\.js)?$/u, ".js");
-}
-
-generate();

package/scripts/update-adapter-typings.ts

@@ -1,71 +0,0 @@
-import fs from "fs";
-import https from "https";
-import resolvePkg from "resolve-pkg";
-
-// Get the @arcgis/core installed version
-const corePackagePath = resolvePkg("@arcgis/core/package.json");
-if (!corePackagePath) {
-  console.error("Unable to find @arcgis/core package.json");
-  process.exit(1);
-}
-const corePackage = JSON.parse(fs.readFileSync(corePackagePath, "utf-8")) as { version: string };
-const coreVersion = corePackage.version.split(".").slice(0, 2).join(".");
-console.log(`Using ArcGIS Typings version ${coreVersion}`);
-
-// The typings are hosted on jsapi.esri.com and are versioned based on the system version.
-const files = [
-  {
-    source: `https://jsapi.esri.com/typings/arcgis-js-api-${coreVersion}.d.ts`,
-    destination: `${process.cwd()}/support/arcgis.d.ts`,
-  },
-  {
-    source: `https://jsapi.esri.com/typings/api-reference-esm-imports-${coreVersion}.json`,
-    destination: `${process.cwd()}/support/api-reference-esm-imports.json`,
-  },
-];
-
-// 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) => {
-      console.log("Downloaded:", source);
-      console.log(`Response type: ${resp.headers["content-type"]}`);
-
-      resp.pipe(file);
-
-      resp.on("error", (err) => {
-        console.error(`Request error for ${source}:`, err);
-        reject(err);
-      });
-
-      file.on("error", (err) => {
-        console.error(`Writing error for ${destination}:`, err);
-        reject(err);
-      });
-
-      file.on("finish", () => {
-        file.close();
-        resolve(undefined);
-      });
-    });
-  });
-}
-
-Promise.allSettled(
-  files.map(async ({ source, destination }): Promise<void> => await downloadSupportFiles(source, destination)),
-)
-  .then(() => {
-    console.log(`ArcGIS Typings and support files for ${coreVersion} updated`);
-  })
-  .catch((err: Error) => {
-    console.error(err.message);
-    process.exit(1);
-  });