@iconify/tools 4.2.0 → 5.0.0-beta.2

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

@@ -1,29 +1,20 @@
-import { APICacheOptions } from '../../download/api/types.js';
-import { DocumentNotModified } from '../../download/types/modified.js';
-import { FigmaDocument } from './types/api.js';
-import { FigmaIfModifiedSinceOption, FigmaFilesQueryOptions, FigmaImagesQueryOptions } from './types/options.js';
-import { FigmaNodesImportResult, FigmaIconNode } from './types/result.js';
-import '../../icon-set/index.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../../icon-set/types.js';
-import '../../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-import './types/nodes.js';
-
+import { APICacheOptions } from "../../download/api/types.js";
+import { DocumentNotModified } from "../../download/types/modified.js";
+import { FigmaDocument } from "./types/api.js";
+import { FigmaIconNode, FigmaNodesImportResult } from "./types/result.js";
+import { FigmaFilesQueryOptions, FigmaIfModifiedSinceOption, FigmaImagesQueryOptions } from "./types/options.js";
 /**
  * Extra parameters added to runConcurrentQueries()
  *
  * Can be used to identify failed items in onfail callback
  */
 interface FigmaIconNodeWithURL extends FigmaIconNode {
-    url: string;
+  url: string;
 }
 type FigmaConcurrentQueriesParamsFunction = 'figmaImagesQuery' | 'figmaDownloadImages';
 interface FigmaConcurrentQueriesParams<T extends FigmaConcurrentQueriesParamsFunction> {
-    function: T;
-    payload: T extends 'figmaImagesQuery' ? string[][] : FigmaIconNodeWithURL[];
+  function: T;
+  payload: T extends 'figmaImagesQuery' ? string[][] : FigmaIconNodeWithURL[];
 }
 /**
  * Get Figma files
@@ -38,5 +29,4 @@ declare function figmaImagesQuery(options: FigmaImagesQueryOptions, nodes: Figma
  * Download all images
  */
 declare function figmaDownloadImages(nodes: FigmaNodesImportResult, cache?: APICacheOptions): Promise<FigmaNodesImportResult>;
-
-export { type FigmaConcurrentQueriesParams, type FigmaConcurrentQueriesParamsFunction, figmaDownloadImages, figmaFilesQuery, figmaImagesQuery };
+export { FigmaConcurrentQueriesParams, FigmaConcurrentQueriesParamsFunction, figmaDownloadImages, figmaFilesQuery, figmaImagesQuery };

package/lib/import/figma/query.js

@@ -0,0 +1,183 @@
+import { apiCacheKey, clearAPICache, getAPICache } from "../../download/api/cache.js";
+import { sendAPIQuery } from "../../download/api/index.js";
+import { runConcurrentQueries } from "../../download/api/queue.js";
+
+/**
+* Compare last modified dates
+*/
+function identicalDates(actual, expected) {
+	if (typeof actual !== "string") return false;
+	if (actual === expected) return true;
+	return new Date(actual).toString() === new Date(expected).toString();
+}
+async function figmaFilesQuery(options, cache) {
+	if (!options.token) throw new Error("Missing Figma API token");
+	const params = new URLSearchParams();
+	if (options.ids) params.set("ids", options.ids.join(","));
+	if (options.version) params.set("version", options.version);
+	if (options.depth) params.set("depth", options.depth.toString());
+	const queryParams = {
+		uri: "https://api.figma.com/v1/files/" + options.file,
+		params,
+		headers: { "X-FIGMA-TOKEN": options.token }
+	};
+	const isModified = async () => {
+		if (!cache || !options.ifModifiedSince) return true;
+		const cacheKey = apiCacheKey(queryParams);
+		const cachedData = await getAPICache(cache.dir, cacheKey);
+		if (!cachedData) return true;
+		let ifModifiedSince;
+		if (options.ifModifiedSince === true) try {
+			const parsedData$1 = JSON.parse(cachedData);
+			if (typeof parsedData$1.lastModified !== "string") {
+				await clearAPICache(cache.dir);
+				return true;
+			}
+			ifModifiedSince = parsedData$1.lastModified;
+		} catch (err) {
+			await clearAPICache(cache.dir);
+			return true;
+		}
+		else ifModifiedSince = options.ifModifiedSince;
+		const versionCheckParams = {
+			...queryParams,
+			params: new URLSearchParams(params)
+		};
+		versionCheckParams.params.set("depth", "1");
+		const data$1 = await sendAPIQuery(versionCheckParams);
+		try {
+			if (typeof data$1 === "string") {
+				if (identicalDates(JSON.parse(data$1).lastModified, ifModifiedSince)) return false;
+			}
+		} catch (err) {}
+		await clearAPICache(cache.dir);
+		return true;
+	};
+	if (!await isModified()) return "not_modified";
+	const data = await sendAPIQuery(queryParams, cache);
+	if (typeof data === "number") throw new Error(`Error retrieving document from API: ${data}`);
+	let parsedData;
+	try {
+		parsedData = JSON.parse(data);
+	} catch (err) {
+		throw new Error(`Error retrieving document from API: invalid data`);
+	}
+	if (typeof parsedData.status === "number") {
+		const figmaError = parsedData;
+		throw new Error(`Error retrieving document from API: ${figmaError.err}`);
+	}
+	const document = parsedData;
+	if (document.editorType !== "figma") throw new Error(`Error retrieving document from API: document is for ${document.editorType}`);
+	if (identicalDates(options.ifModifiedSince, document.lastModified)) return "not_modified";
+	return document;
+}
+/**
+* Generate all images
+*/
+async function figmaImagesQuery(options, nodes, cache) {
+	const uri = "https://api.figma.com/v1/images/" + options.file;
+	const maxLength = 2048 - uri.length;
+	const svgOptions = options.svgOptions || {};
+	const query = (ids$1) => {
+		return new Promise((resolve, reject) => {
+			const params = new URLSearchParams({
+				ids: ids$1.join(","),
+				format: "svg"
+			});
+			if (options.version) params.set("version", options.version);
+			params.set("svg_include_id", svgOptions.includeID ? "true" : "false");
+			params.set("svg_simplify_stroke", svgOptions.simplifyStroke ? "true" : "false");
+			params.set("use_absolute_bounds", svgOptions.useAbsoluteBounds ? "true" : "false");
+			sendAPIQuery({
+				uri,
+				params,
+				headers: { "X-FIGMA-TOKEN": options.token }
+			}, cache).then((data) => {
+				if (typeof data === "number") {
+					reject(data);
+					return;
+				}
+				let parsedData;
+				try {
+					parsedData = JSON.parse(data);
+				} catch {
+					reject("Bad API response");
+					return;
+				}
+				resolve(parsedData);
+			}).catch(reject);
+		});
+	};
+	let ids = [];
+	let idsLength = 0;
+	const allKeys = Object.keys(nodes.icons);
+	const queue = [];
+	for (let i = 0; i < allKeys.length; i++) {
+		const id = allKeys[i];
+		ids.push(id);
+		idsLength += id.length + 1;
+		if (idsLength >= maxLength) {
+			queue.push(ids.slice(0));
+			ids = [];
+			idsLength = 0;
+		}
+	}
+	if (idsLength) queue.push(ids.slice(0));
+	const results = await runConcurrentQueries({
+		total: queue.length,
+		callback: (index) => query(queue[index]),
+		function: "figmaImagesQuery",
+		payload: queue
+	});
+	let found = 0;
+	results.forEach((data) => {
+		if (!data) return;
+		const images = data.images;
+		for (const id in images) {
+			const node = nodes.icons[id];
+			const target = images[id];
+			if (node && target) {
+				node.url = target;
+				found++;
+			}
+		}
+	});
+	if (!found) throw new Error("No valid icon layers were found");
+	nodes.generatedIconsCount = found;
+	return nodes;
+}
+/**
+* Download all images
+*/
+async function figmaDownloadImages(nodes, cache) {
+	const icons = nodes.icons;
+	const ids = Object.keys(icons);
+	let count = 0;
+	const filtered = [];
+	for (let i = 0; i < ids.length; i++) {
+		const item = icons[ids[i]];
+		if (item.url) filtered.push(item);
+	}
+	await runConcurrentQueries({
+		total: filtered.length,
+		callback: (index) => {
+			return new Promise((resolve, reject) => {
+				const item = filtered[index];
+				sendAPIQuery({ uri: item.url }, cache).then((data) => {
+					if (typeof data === "string") {
+						count++;
+						item.content = data;
+						resolve(void 0);
+					} else reject(data);
+				}).catch(reject);
+			});
+		},
+		function: "figmaDownloadImages",
+		payload: filtered
+	});
+	if (!count) throw new Error("Error retrieving images");
+	nodes.downloadedIconsCount = count;
+	return nodes;
+}
+
+export { figmaDownloadImages, figmaFilesQuery, figmaImagesQuery };

package/lib/import/figma/types/api.d.ts

@@ -2,52 +2,51 @@
  * Basic document structure
  */
 interface FigmaBoundingBox {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
 }
 interface BaseFigmaNode {
-    id: string;
-    name: string;
+  id: string;
+  name: string;
 }
 interface GenericFigmaNode extends BaseFigmaNode {
-    type: string;
-    children?: FigmaNode[];
+  type: string;
+  children?: FigmaNode[];
 }
 interface IconFigmaNode extends BaseFigmaNode {
-    type: 'FRAME' | 'COMPONENT' | 'INSTANCE';
-    clipsContent?: boolean;
-    absoluteBoundingBox?: FigmaBoundingBox;
-    children: FigmaNode[];
+  type: 'FRAME' | 'COMPONENT' | 'INSTANCE';
+  clipsContent?: boolean;
+  absoluteBoundingBox?: FigmaBoundingBox;
+  children: FigmaNode[];
 }
 interface FigmaDocumentNode extends BaseFigmaNode {
-    type: 'DOCUMENT';
-    children: FigmaNode[];
+  type: 'DOCUMENT';
+  children: FigmaNode[];
 }
 type FigmaNode = GenericFigmaNode | IconFigmaNode;
 /**
  * Document response from API
  */
 interface FigmaDocument {
-    document: FigmaDocumentNode;
-    name: string;
-    version: string;
-    lastModified: string;
-    thumbnailUrl: string;
-    role: string;
-    editorType: 'figma' | 'figjam';
+  document: FigmaDocumentNode;
+  name: string;
+  version: string;
+  lastModified: string;
+  thumbnailUrl: string;
+  role: string;
+  editorType: 'figma' | 'figjam';
 }
 interface FigmaAPIError {
-    status: number;
-    err: string;
+  status: number;
+  err: string;
 }
 /**
  * Result for retrieved icons
  */
 interface FigmaAPIImagesResponse {
-    err?: string | null;
-    images: Record<string, string | null>;
+  err?: string | null;
+  images: Record<string, string | null>;
 }
-
-export type { FigmaAPIError, FigmaAPIImagesResponse, FigmaDocument, FigmaDocumentNode, FigmaNode, IconFigmaNode };
+export { FigmaAPIError, FigmaAPIImagesResponse, FigmaDocument, FigmaDocumentNode, FigmaNode, IconFigmaNode };

package/lib/import/figma/types/api.js

@@ -0,0 +1 @@
+export {  };

package/lib/import/figma/types/nodes.d.ts

@@ -1,30 +1,22 @@
-import { IconFigmaNode, FigmaDocument } from './api.js';
-import { FigmaNodesImportResult, FigmaIconNode } from './result.js';
-import '../../../icon-set/index.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../../../icon-set/types.js';
-import '../../../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-
+import { FigmaDocument, IconFigmaNode } from "./api.js";
+import { FigmaIconNode, FigmaNodesImportResult } from "./result.js";
 type FigmaImportParentNodeType = 'CANVAS' | 'FRAME' | 'GROUP' | 'SECTION' | 'COMPONENT_SET';
 type FigmaImportIconNodeType = IconFigmaNode['type'];
 /**
  * Node information passed to callback
  */
 interface FigmaParentNodeData {
-    id: string;
-    type: FigmaImportParentNodeType;
-    name: string;
+  id: string;
+  type: FigmaImportParentNodeType;
+  name: string;
 }
 interface FigmaImportNodeData {
-    id: string;
-    type: FigmaImportIconNodeType;
-    name: string;
-    width: number;
-    height: number;
-    parents: FigmaParentNodeData[];
+  id: string;
+  type: FigmaImportIconNodeType;
+  name: string;
+  width: number;
+  height: number;
+  parents: FigmaParentNodeData[];
 }
 /**
  * Callback to check if node needs to be checked for icons
@@ -40,5 +32,4 @@ type FigmaImportParentNodeFilter = (node: FigmaParentNodeData[], document: Figma
  */
 type FigmaIconNodeWithKeyword = Partial<FigmaIconNode> & Pick<FigmaIconNode, 'keyword'>;
 type FigmaImportNodeFilter = (node: FigmaImportNodeData, nodes: FigmaNodesImportResult, document: FigmaDocument) => string | FigmaIconNodeWithKeyword | null | undefined;
-
-export type { FigmaImportIconNodeType, FigmaImportNodeData, FigmaImportNodeFilter, FigmaImportParentNodeFilter, FigmaImportParentNodeType, FigmaParentNodeData };
+export { FigmaImportIconNodeType, FigmaImportNodeData, FigmaImportNodeFilter, FigmaImportParentNodeFilter, FigmaImportParentNodeType, FigmaParentNodeData };

package/lib/import/figma/types/nodes.js

@@ -0,0 +1 @@
+export {  };

package/lib/import/figma/types/options.d.ts

@@ -1,44 +1,36 @@
-import { IconSet } from '../../../icon-set/index.js';
-import { FigmaImportParentNodeFilter, FigmaImportNodeFilter } from './nodes.js';
-import { FigmaIconNode } from './result.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../../../icon-set/types.js';
-import '../../../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-import './api.js';
-
+import { IconSet } from "../../../icon-set/index.js";
+import { FigmaIconNode } from "./result.js";
+import { FigmaImportNodeFilter, FigmaImportParentNodeFilter } from "./nodes.js";
 /**
  * Options for importing SVG
  */
 interface FigmaImportSVGOptions {
-    includeID?: boolean;
-    simplifyStroke?: boolean;
-    useAbsoluteBounds?: boolean;
+  includeID?: boolean;
+  simplifyStroke?: boolean;
+  useAbsoluteBounds?: boolean;
 }
 /**
  * Options
  */
 interface FigmaImportCommonOptions {
-    token: string;
-    file: string;
-    version?: string;
+  token: string;
+  file: string;
+  version?: string;
 }
 interface FigmaIfModifiedSinceOption {
-    ifModifiedSince: string | Date | true;
+  ifModifiedSince: string | Date | true;
 }
 interface FigmaFilesQueryOptions extends FigmaImportCommonOptions, Partial<FigmaIfModifiedSinceOption> {
-    ids?: string[];
-    depth?: number;
+  ids?: string[];
+  depth?: number;
 }
 interface FigmaImagesQueryOptions extends FigmaImportCommonOptions {
-    svgOptions?: FigmaImportSVGOptions;
+  svgOptions?: FigmaImportSVGOptions;
 }
 interface FigmaGetIconNodesOptions {
-    pages?: string[];
-    filterParentNode?: FigmaImportParentNodeFilter;
-    iconNameForNode: FigmaImportNodeFilter;
+  pages?: string[];
+  filterParentNode?: FigmaImportParentNodeFilter;
+  iconNameForNode: FigmaImportNodeFilter;
 }
 /**
  * Callback to call before or after importing icon
@@ -48,12 +40,11 @@ type FigmaImportedIconCallback = (node: FigmaIconNode, iconSet: IconSet) => void
  * Options for main import function
  */
 interface FigmaImportOptions extends FigmaFilesQueryOptions, FigmaImagesQueryOptions, FigmaGetIconNodesOptions {
-    prefix: string;
-    cacheDir?: string;
-    cacheAPITTL?: number;
-    cacheSVGTTL?: number;
-    beforeImportingIcon?: FigmaImportedIconCallback;
-    afterImportingIcon?: FigmaImportedIconCallback;
+  prefix: string;
+  cacheDir?: string;
+  cacheAPITTL?: number;
+  cacheSVGTTL?: number;
+  beforeImportingIcon?: FigmaImportedIconCallback;
+  afterImportingIcon?: FigmaImportedIconCallback;
 }
-
-export type { FigmaFilesQueryOptions, FigmaGetIconNodesOptions, FigmaIfModifiedSinceOption, FigmaImagesQueryOptions, FigmaImportOptions, FigmaImportSVGOptions };
+export { FigmaFilesQueryOptions, FigmaGetIconNodesOptions, FigmaIfModifiedSinceOption, FigmaImagesQueryOptions, FigmaImportOptions, FigmaImportSVGOptions };

package/lib/import/figma/types/options.js

@@ -0,0 +1 @@
+export {  };

package/lib/import/figma/types/result.d.ts

@@ -1,44 +1,36 @@
-import { IconSet } from '../../../icon-set/index.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../../../icon-set/types.js';
-import '../../../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-
+import { IconSet } from "../../../icon-set/index.js";
 /**
  * Result for found icons
  */
 interface FigmaIconNode {
-    id: string;
-    name: string;
-    keyword: string;
-    url?: string;
-    content?: string;
+  id: string;
+  name: string;
+  keyword: string;
+  url?: string;
+  content?: string;
 }
 /**
  * Nodes count
  */
 interface FigmaNodesCount {
-    nodesCount: number;
-    generatedIconsCount: number;
-    downloadedIconsCount: number;
+  nodesCount: number;
+  generatedIconsCount: number;
+  downloadedIconsCount: number;
 }
 /**
  * Import result for icons
  */
 interface FigmaNodesImportResult extends Partial<FigmaNodesCount> {
-    icons: Record<string, FigmaIconNode>;
+  icons: Record<string, FigmaIconNode>;
 }
 /**
  * Import result
  */
 interface FigmaImportResult extends FigmaNodesCount {
-    name: string;
-    version: string;
-    lastModified: string;
-    iconSet: IconSet;
-    missing: FigmaIconNode[];
+  name: string;
+  version: string;
+  lastModified: string;
+  iconSet: IconSet;
+  missing: FigmaIconNode[];
 }
-
-export type { FigmaIconNode, FigmaImportResult, FigmaNodesCount, FigmaNodesImportResult };
+export { FigmaIconNode, FigmaImportResult, FigmaNodesCount, FigmaNodesImportResult };

package/lib/import/figma/types/result.js

@@ -0,0 +1 @@
+export {  };