@iconify/tools 2.0.0-dev.3 → 2.0.2

package/lib/export/{prepare.js → helpers/prepare.js}

@@ -1,8 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareDirectoryForExport = void 0;
+exports.prepareDirectoryForExport = exports.normalizeDir = void 0;
 const fs_1 = require("fs");
 const pathe_1 = require("pathe");
+/**
+ * Normalize directory
+ */
+function normalizeDir(dir) {
+    // Normalise directory
+    dir = (0, pathe_1.normalize)(dir);
+    if (dir.slice(-1) === '/') {
+        dir = dir.slice(0, -1);
+    }
+    return dir;
+}
+exports.normalizeDir = normalizeDir;
 /**
  * Prepare directory for export
  *
@@ -10,10 +22,7 @@ const pathe_1 = require("pathe");
  */
 async function prepareDirectoryForExport(options) {
     // Normalise directory
-    let dir = (0, pathe_1.normalize)(options.target);
-    if (dir.slice(-1) === '/') {
-        dir = dir.slice(0, dir.length - 1);
-    }
+    const dir = normalizeDir(options.target);
     if (options.cleanup) {
         // Remove old files
         try {

package/lib/export/{prepare.mjs → helpers/prepare.mjs}

@@ -1,11 +1,15 @@
-// src/export/prepare.ts
+// src/export/helpers/prepare.ts
 import { promises as fs } from "fs";
 import { normalize } from "pathe";
-async function prepareDirectoryForExport(options) {
-  let dir = normalize(options.target);
+function normalizeDir(dir) {
+  dir = normalize(dir);
   if (dir.slice(-1) === "/") {
-    dir = dir.slice(0, dir.length - 1);
+    dir = dir.slice(0, -1);
   }
+  return dir;
+}
+async function prepareDirectoryForExport(options) {
+  const dir = normalizeDir(options.target);
   if (options.cleanup) {
     try {
       await fs.rm(dir, {
@@ -24,5 +28,6 @@ async function prepareDirectoryForExport(options) {
   return dir;
 }
 export {
+  normalizeDir,
   prepareDirectoryForExport
 };

package/lib/export/helpers/types-version.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get current version of Iconify Types package
+ */
+export declare function getTypesVersion(): string;

package/lib/export/helpers/types-version.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypesVersion = void 0;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('@iconify/types/package.json');
+/**
+ * Get current version of Iconify Types package
+ */
+function getTypesVersion() {
+    return pkg.version;
+}
+exports.getTypesVersion = getTypesVersion;

package/lib/export/helpers/types-version.mjs

@@ -0,0 +1,40 @@
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// ../../node_modules/@iconify/types/package.json
+var require_package = __commonJS({
+  "../../node_modules/@iconify/types/package.json"(exports, module) {
+    module.exports = {
+      name: "@iconify/types",
+      description: "Types for Iconify data",
+      version: "1.0.12",
+      author: "Vjacheslav Trushkin",
+      license: "(Apache-2.0 OR GPL-2.0)",
+      main: "./index.js",
+      types: "./types.ts",
+      scripts: {
+        test: "tsc --noEmit --strict --typeRoots '[]' types.ts"
+      },
+      bugs: "https://github.com/iconify/iconify/issues",
+      homepage: "https://github.com/iconify/iconify",
+      repository: {
+        type: "git",
+        url: "https://github.com/iconify/iconify.git",
+        directory: "packages/types"
+      },
+      devDependencies: {
+        typescript: "^4.4.3"
+      }
+    };
+  }
+});
+
+// src/export/helpers/types-version.ts
+var pkg = require_package();
+function getTypesVersion() {
+  return pkg.version;
+}
+export {
+  getTypesVersion
+};

package/lib/export/icon-package.d.ts

@@ -0,0 +1,17 @@
+import type { IconSet } from '../icon-set';
+import type { ExportTargetOptions } from './helpers/prepare';
+import { ExportOptionsWithCustomFiles } from './helpers/custom-files';
+/**
+ * Options
+ */
+export interface ExportIconPackageOptions extends ExportTargetOptions, ExportOptionsWithCustomFiles {
+    package?: Record<string, unknown>;
+    module?: boolean;
+    typesContent?: string;
+}
+/**
+ * Export icon set as single icon packages
+ *
+ * Used for exporting `@iconify-icons/{prefix}` packages
+ */
+export declare function exportIconPackage(iconSet: IconSet, options: ExportIconPackageOptions): Promise<string[]>;

package/lib/export/icon-package.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportIconPackage = void 0;
+const fs_1 = require("fs");
+const prepare_1 = require("./helpers/prepare");
+const write_json_1 = require("../misc/write-json");
+const types_version_1 = require("./helpers/types-version");
+const custom_files_1 = require("./helpers/custom-files");
+/**
+ * Content for .d.ts files
+ */
+const defaultTypesContent = `import type { IconifyIcon } from '@iconify/types';
+declare const data: IconifyIcon;
+export default data;
+`;
+/**
+ * Export icon set as single icon packages
+ *
+ * Used for exporting `@iconify-icons/{prefix}` packages
+ */
+async function exportIconPackage(iconSet, options) {
+    const files = new Set();
+    const esm = options.module !== false;
+    // Normalise and prepare directory
+    const dir = await (0, prepare_1.prepareDirectoryForExport)(options);
+    // Write all icons
+    const typesContent = options.typesContent || defaultTypesContent;
+    await iconSet.forEach(async (name) => {
+        const data = iconSet.resolve(name, false);
+        if (!data) {
+            return;
+        }
+        // Store types
+        const typesFilename = name + '.d.ts';
+        await fs_1.promises.writeFile(`${dir}/${typesFilename}`, typesContent, 'utf8');
+        files.add(typesFilename);
+        // Generate content
+        let content = `const data = ` + JSON.stringify(data, null, '\t') + ';\n';
+        if (!esm) {
+            // CJS module
+            content += 'exports.__esModule = true;\nexports.default = data;\n';
+        }
+        else {
+            // ES module
+            content += 'export default data;\n';
+        }
+        const contentFilename = name + '.js';
+        await fs_1.promises.writeFile(`${dir}/${contentFilename}`, content, 'utf8');
+        files.add(contentFilename);
+    });
+    // Write custom files
+    await (0, custom_files_1.exportCustomFiles)(dir, options, files);
+    // Generate package.json
+    const info = iconSet.info;
+    const { name, description, version, dependencies, ...customPackageProps } = options.package || {};
+    const packageJSON = {
+        name: name ||
+            (esm
+                ? `@iconify-icons/${iconSet.prefix}`
+                : `@iconify/icons-${iconSet.prefix}`),
+        description: description ||
+            `Iconify icon components for ${info ? info.name : iconSet.prefix}`,
+        version,
+        type: esm ? 'module' : void 0,
+        iconSetInfo: info,
+        ...customPackageProps,
+        dependencies: dependencies || {
+            '@iconify/types': '^' + (0, types_version_1.getTypesVersion)(),
+        },
+    };
+    // Save package.json
+    await (0, write_json_1.writeJSONFile)(dir + '/package.json', packageJSON);
+    files.add('package.json');
+    // Return list of stored files as array
+    return Array.from(files);
+}
+exports.exportIconPackage = exportIconPackage;

package/lib/export/icon-package.mjs

@@ -0,0 +1,56 @@
+// src/export/icon-package.ts
+import { promises as fs } from "fs";
+import { prepareDirectoryForExport } from "./helpers/prepare.mjs";
+import { writeJSONFile } from "../misc/write-json.mjs";
+import { getTypesVersion } from "./helpers/types-version.mjs";
+import {
+  exportCustomFiles
+} from "./helpers/custom-files.mjs";
+var defaultTypesContent = `import type { IconifyIcon } from '@iconify/types';
+declare const data: IconifyIcon;
+export default data;
+`;
+async function exportIconPackage(iconSet, options) {
+  const files = new Set();
+  const esm = options.module !== false;
+  const dir = await prepareDirectoryForExport(options);
+  const typesContent = options.typesContent || defaultTypesContent;
+  await iconSet.forEach(async (name2) => {
+    const data = iconSet.resolve(name2, false);
+    if (!data) {
+      return;
+    }
+    const typesFilename = name2 + ".d.ts";
+    await fs.writeFile(`${dir}/${typesFilename}`, typesContent, "utf8");
+    files.add(typesFilename);
+    let content = `const data = ` + JSON.stringify(data, null, "	") + ";\n";
+    if (!esm) {
+      content += "exports.__esModule = true;\nexports.default = data;\n";
+    } else {
+      content += "export default data;\n";
+    }
+    const contentFilename = name2 + ".js";
+    await fs.writeFile(`${dir}/${contentFilename}`, content, "utf8");
+    files.add(contentFilename);
+  });
+  await exportCustomFiles(dir, options, files);
+  const info = iconSet.info;
+  const { name, description, version, dependencies, ...customPackageProps } = options.package || {};
+  const packageJSON = {
+    name: name || (esm ? `@iconify-icons/${iconSet.prefix}` : `@iconify/icons-${iconSet.prefix}`),
+    description: description || `Iconify icon components for ${info ? info.name : iconSet.prefix}`,
+    version,
+    type: esm ? "module" : void 0,
+    iconSetInfo: info,
+    ...customPackageProps,
+    dependencies: dependencies || {
+      "@iconify/types": "^" + getTypesVersion()
+    }
+  };
+  await writeJSONFile(dir + "/package.json", packageJSON);
+  files.add("package.json");
+  return Array.from(files);
+}
+export {
+  exportIconPackage
+};

package/lib/export/json-package.d.ts

@@ -0,0 +1,15 @@
+import type { IconSet } from '../icon-set';
+import type { ExportTargetOptions } from './helpers/prepare';
+import { ExportOptionsWithCustomFiles } from './helpers/custom-files';
+/**
+ * Options
+ */
+export interface ExportJSONPackageOptions extends ExportTargetOptions, ExportOptionsWithCustomFiles {
+    package?: Record<string, unknown>;
+}
+/**
+ * Export icon set as JSON package
+ *
+ * Used for exporting `@iconify-json/{prefix}` packages
+ */
+export declare function exportJSONPackage(iconSet: IconSet, options: ExportJSONPackageOptions): Promise<string[]>;

package/lib/export/json-package.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportJSONPackage = void 0;
+const fs_1 = require("fs");
+const icon_1 = require("@iconify/utils/lib/icon");
+const prepare_1 = require("./helpers/prepare");
+const write_json_1 = require("../misc/write-json");
+const types_version_1 = require("./helpers/types-version");
+const custom_files_1 = require("./helpers/custom-files");
+const exportTypes = {
+    icons: 'IconifyJSON',
+    info: 'IconifyInfo',
+    metadata: 'IconifyMetaData',
+    chars: 'IconifyChars',
+};
+const iconsKeys = ['aliases'].concat(Object.keys(icon_1.iconDefaults));
+const metadataKeys = [
+    'categories',
+    'themes',
+    'prefixes',
+    'suffixes',
+];
+/**
+ * Export icon set as JSON package
+ *
+ * Used for exporting `@iconify-json/{prefix}` packages
+ */
+async function exportJSONPackage(iconSet, options) {
+    const files = new Set();
+    // Normalise and prepare directory
+    const dir = await (0, prepare_1.prepareDirectoryForExport)(options);
+    // Export icon set to IconifyJSON format
+    const exportedJSON = iconSet.export(true);
+    // Get icons
+    const icons = {
+        prefix: exportedJSON.prefix,
+        icons: exportedJSON.icons,
+    };
+    iconsKeys.forEach((attr) => {
+        if (exportedJSON[attr] !== void 0) {
+            icons[attr] = exportedJSON[attr];
+        }
+    });
+    // Get metadata
+    const metadata = {};
+    let hasMetadata = false;
+    metadataKeys.forEach((attr) => {
+        if (exportedJSON[attr]) {
+            metadata[attr] = exportedJSON[attr];
+            hasMetadata = true;
+        }
+    });
+    // Contents
+    const info = exportedJSON.info;
+    const contents = {
+        icons,
+        info,
+        metadata: hasMetadata ? metadata : void 0,
+        chars: exportedJSON.chars,
+    };
+    // Generate package.json
+    const { name, description, version, dependencies, ...customPackageProps } = options.package || {};
+    const packageJSONIconSet = {};
+    const packageJSONExports = {
+        './*': './*',
+        '.': {
+            require: './index.js',
+            import: './index.mjs',
+        },
+    };
+    const packageJSON = {
+        name: name || `@iconify-json/${iconSet.prefix}`,
+        description: description ||
+            `${info ? info.name : iconSet.prefix} icon set in Iconify JSON format`,
+        version,
+        iconSetVersion: info === null || info === void 0 ? void 0 : info.version,
+        main: 'index.js',
+        module: 'index.mjs',
+        types: 'index.d.ts',
+        ...customPackageProps,
+        exports: packageJSONExports,
+        iconSet: packageJSONIconSet,
+        dependencies: dependencies || {
+            '@iconify/types': '^' + (0, types_version_1.getTypesVersion)(),
+        },
+    };
+    // Save all files, generate exports
+    const dtsContent = [];
+    const cjsImports = [];
+    const cjsExports = [];
+    const mjsImports = [];
+    const mjsConsts = [];
+    const mjsExports = [];
+    for (const key in contents) {
+        const attr = key;
+        const data = contents[attr];
+        const type = exportTypes[attr];
+        const jsonFilename = attr + '.json';
+        const relativeFile = `./${jsonFilename}`;
+        // Add type
+        dtsContent.push(`export declare const ${attr}: ${type};`);
+        // Export variable
+        cjsExports.push(`exports.${attr} = ${attr};`);
+        mjsExports.push(attr);
+        if (data !== void 0) {
+            // Save JSON file
+            await (0, write_json_1.writeJSONFile)(`${dir}/${jsonFilename}`, data);
+            // Import data from JSON file
+            cjsImports.push(`const ${attr} = require('${relativeFile}');`);
+            mjsImports.push(`import ${attr} from '${relativeFile}';`);
+            // Add data to package.json
+            packageJSONIconSet[attr] = attr + '.json';
+            packageJSONExports[relativeFile] = relativeFile;
+        }
+        else {
+            // Create empty data
+            await (0, write_json_1.writeJSONFile)(`${dir}/${jsonFilename}`, {});
+            cjsImports.push(`const ${attr} = {};`);
+            mjsConsts.push(`const ${attr} = {};`);
+        }
+        files.add(jsonFilename);
+    }
+    // Generate CJS index file
+    const cjsContent = cjsImports.concat([''], cjsExports);
+    await fs_1.promises.writeFile(dir + '/index.js', cjsContent.join('\n') + '\n', 'utf8');
+    files.add('index.js');
+    // Generate MJS index file
+    const mjsContent = mjsImports.concat([''], mjsConsts, [
+        `export { ${mjsExports.join(', ')} };`,
+    ]);
+    await fs_1.promises.writeFile(dir + '/index.mjs', mjsContent.join('\n') + '\n', 'utf8');
+    files.add('index.mjs');
+    // Generate types file
+    const usedTypes = Object.values(exportTypes);
+    const typesData = [
+        `import type { ${usedTypes.join(', ')} } from '@iconify/types';`,
+        '',
+        `export { ${usedTypes.join(', ')} };`,
+        '',
+    ].concat(dtsContent);
+    await fs_1.promises.writeFile(dir + '/index.d.ts', typesData.join('\n') + '\n', 'utf8');
+    files.add('index.d.ts');
+    // Write custom files
+    await (0, custom_files_1.exportCustomFiles)(dir, options, files);
+    // Save package.json
+    await (0, write_json_1.writeJSONFile)(dir + '/package.json', packageJSON);
+    files.add('package.json');
+    // Return list of stored files as array
+    return Array.from(files);
+}
+exports.exportJSONPackage = exportJSONPackage;

package/lib/export/json-package.mjs

@@ -0,0 +1,127 @@
+// src/export/json-package.ts
+import { promises as fs } from "fs";
+import { iconDefaults } from "@iconify/utils/lib/icon";
+import { prepareDirectoryForExport } from "./helpers/prepare.mjs";
+import { writeJSONFile } from "../misc/write-json.mjs";
+import { getTypesVersion } from "./helpers/types-version.mjs";
+import {
+  exportCustomFiles
+} from "./helpers/custom-files.mjs";
+var exportTypes = {
+  icons: "IconifyJSON",
+  info: "IconifyInfo",
+  metadata: "IconifyMetaData",
+  chars: "IconifyChars"
+};
+var iconsKeys = ["aliases"].concat(Object.keys(iconDefaults));
+var metadataKeys = [
+  "categories",
+  "themes",
+  "prefixes",
+  "suffixes"
+];
+async function exportJSONPackage(iconSet, options) {
+  const files = new Set();
+  const dir = await prepareDirectoryForExport(options);
+  const exportedJSON = iconSet.export(true);
+  const icons = {
+    prefix: exportedJSON.prefix,
+    icons: exportedJSON.icons
+  };
+  iconsKeys.forEach((attr) => {
+    if (exportedJSON[attr] !== void 0) {
+      icons[attr] = exportedJSON[attr];
+    }
+  });
+  const metadata = {};
+  let hasMetadata = false;
+  metadataKeys.forEach((attr) => {
+    if (exportedJSON[attr]) {
+      metadata[attr] = exportedJSON[attr];
+      hasMetadata = true;
+    }
+  });
+  const info = exportedJSON.info;
+  const contents = {
+    icons,
+    info,
+    metadata: hasMetadata ? metadata : void 0,
+    chars: exportedJSON.chars
+  };
+  const { name, description, version, dependencies, ...customPackageProps } = options.package || {};
+  const packageJSONIconSet = {};
+  const packageJSONExports = {
+    "./*": "./*",
+    ".": {
+      require: "./index.js",
+      import: "./index.mjs"
+    }
+  };
+  const packageJSON = {
+    name: name || `@iconify-json/${iconSet.prefix}`,
+    description: description || `${info ? info.name : iconSet.prefix} icon set in Iconify JSON format`,
+    version,
+    iconSetVersion: info == null ? void 0 : info.version,
+    main: "index.js",
+    module: "index.mjs",
+    types: "index.d.ts",
+    ...customPackageProps,
+    exports: packageJSONExports,
+    iconSet: packageJSONIconSet,
+    dependencies: dependencies || {
+      "@iconify/types": "^" + getTypesVersion()
+    }
+  };
+  const dtsContent = [];
+  const cjsImports = [];
+  const cjsExports = [];
+  const mjsImports = [];
+  const mjsConsts = [];
+  const mjsExports = [];
+  for (const key in contents) {
+    const attr = key;
+    const data = contents[attr];
+    const type = exportTypes[attr];
+    const jsonFilename = attr + ".json";
+    const relativeFile = `./${jsonFilename}`;
+    dtsContent.push(`export declare const ${attr}: ${type};`);
+    cjsExports.push(`exports.${attr} = ${attr};`);
+    mjsExports.push(attr);
+    if (data !== void 0) {
+      await writeJSONFile(`${dir}/${jsonFilename}`, data);
+      cjsImports.push(`const ${attr} = require('${relativeFile}');`);
+      mjsImports.push(`import ${attr} from '${relativeFile}';`);
+      packageJSONIconSet[attr] = attr + ".json";
+      packageJSONExports[relativeFile] = relativeFile;
+    } else {
+      await writeJSONFile(`${dir}/${jsonFilename}`, {});
+      cjsImports.push(`const ${attr} = {};`);
+      mjsConsts.push(`const ${attr} = {};`);
+    }
+    files.add(jsonFilename);
+  }
+  const cjsContent = cjsImports.concat([""], cjsExports);
+  await fs.writeFile(dir + "/index.js", cjsContent.join("\n") + "\n", "utf8");
+  files.add("index.js");
+  const mjsContent = mjsImports.concat([""], mjsConsts, [
+    `export { ${mjsExports.join(", ")} };`
+  ]);
+  await fs.writeFile(dir + "/index.mjs", mjsContent.join("\n") + "\n", "utf8");
+  files.add("index.mjs");
+  const usedTypes = Object.values(exportTypes);
+  const typesData = [
+    `import type { ${usedTypes.join(", ")} } from '@iconify/types';`,
+    "",
+    `export { ${usedTypes.join(", ")} };`,
+    ""
+  ].concat(dtsContent);
+  await fs.writeFile(dir + "/index.d.ts", typesData.join("\n") + "\n", "utf8");
+  files.add("index.d.ts");
+  await exportCustomFiles(dir, options, files);
+  await writeJSONFile(dir + "/package.json", packageJSON);
+  files.add("package.json");
+  return Array.from(files);
+}
+export {
+  exportJSONPackage
+};

package/lib/icon-set/index.js

@@ -130,8 +130,7 @@ class IconSet {
                     // Prefix ending with with '-'
                     const prefix = item.prefix;
                     if (prefix.slice(-1) === '-') {
-                        prefixes[prefix.slice(0, prefix.length - 1)] =
-                            item.title;
+                        prefixes[prefix.slice(0, -1)] = item.title;
                     }
                 }
                 if (typeof item.suffix === 'string') {

package/lib/icon-set/index.mjs

@@ -98,7 +98,7 @@ var IconSet = class {
         if (typeof item.prefix === "string") {
           const prefix = item.prefix;
           if (prefix.slice(-1) === "-") {
-            prefixes[prefix.slice(0, prefix.length - 1)] = item.title;
+            prefixes[prefix.slice(0, -1)] = item.title;
           }
         }
         if (typeof item.suffix === "string") {

package/lib/import/figma/index.d.ts

@@ -1,6 +1,8 @@
-import type { FigmaImportOptions } from './types/options';
-import type { FigmaDocumentNotModified, FigmaImportResult } from './types/result';
+import type { DocumentNotModified } from '../../download/types/modified';
+import type { FigmaImportOptions, FigmaIfModifiedSinceOption } from './types/options';
+import type { FigmaImportResult } from './types/result';
 /**
  * Import icon set from Figma
  */
-export declare function importFromFigma(options: FigmaImportOptions): Promise<FigmaImportResult | FigmaDocumentNotModified>;
+export declare function importFromFigma<T extends FigmaIfModifiedSinceOption & FigmaImportOptions>(options: T): Promise<FigmaImportResult | DocumentNotModified>;
+export declare function importFromFigma(options: FigmaImportOptions): Promise<FigmaImportResult>;

package/lib/import/figma/index.js

@@ -6,9 +6,6 @@ const svg_1 = require("../../svg");
 const cleanup_1 = require("../../svg/cleanup");
 const nodes_1 = require("./nodes");
 const query_1 = require("./query");
-/**
- * Import icon set from Figma
- */
 async function importFromFigma(options) {
     const cacheOptions = options.cacheDir
         ? {

package/lib/import/figma/query.d.ts

@@ -1,11 +1,13 @@
-import type { APICacheOptions } from '../../api/types';
+import type { APICacheOptions } from '../../download/api/types';
+import type { DocumentNotModified } from '../../download/types/modified';
 import type { FigmaDocument } from './types/api';
-import type { FigmaFilesQueryOptions, FigmaImagesQueryOptions } from './types/options';
-import type { FigmaDocumentNotModified, FigmaNodesImportResult } from './types/result';
+import type { FigmaIfModifiedSinceOption, FigmaFilesQueryOptions, FigmaImagesQueryOptions } from './types/options';
+import type { FigmaNodesImportResult } from './types/result';
 /**
  * Get Figma files
  */
-export declare function figmaFilesQuery(options: FigmaFilesQueryOptions, cache?: APICacheOptions): Promise<FigmaDocument | FigmaDocumentNotModified>;
+export declare function figmaFilesQuery<T extends FigmaIfModifiedSinceOption & FigmaFilesQueryOptions>(options: T, cache?: APICacheOptions): Promise<FigmaDocument | DocumentNotModified>;
+export declare function figmaFilesQuery(options: FigmaFilesQueryOptions, cache?: APICacheOptions): Promise<FigmaDocument>;
 /**
  * Generate all images
  */

package/lib/import/figma/query.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.figmaDownloadImages = exports.figmaImagesQuery = exports.figmaFilesQuery = void 0;
-const api_1 = require("../../api");
-const cache_1 = require("../../api/cache");
+const api_1 = require("../../download/api");
+const cache_1 = require("../../download/api/cache");
 /**
  * Compare last modified dates
  */
@@ -15,9 +15,6 @@ function identicalDates(actual, expected) {
     }
     return new Date(actual).toString() === new Date(expected).toString();
 }
-/**
- * Get Figma files
- */
 async function figmaFilesQuery(options, cache) {
     // Check token
     if (!options.token) {

package/lib/import/figma/query.mjs

@@ -1,6 +1,10 @@
 // src/import/figma/query.ts
-import { sendAPIQuery } from "../../api/index.mjs";
-import { apiCacheKey, clearAPICache, getAPICache } from "../../api/cache.mjs";
+import { sendAPIQuery } from "../../download/api/index.mjs";
+import {
+  apiCacheKey,
+  clearAPICache,
+  getAPICache
+} from "../../download/api/cache.mjs";
 function identicalDates(actual, expected) {
   if (typeof actual !== "string") {
     return false;