@antv/infographic 0.2.16 → 0.2.18

package/src/templates/utils.ts

@@ -0,0 +1,111 @@
+function normalizeTemplateKey(type: string): string {
+  return type
+    .trim()
+    .toLowerCase()
+    .replace(/[_\s]+/g, '-')
+    .replace(/-+/g, '-');
+}
+
+function getLevenshteinDistance(source: string, target: string): number {
+  if (source === target) return 0;
+  if (!source.length) return target.length;
+  if (!target.length) return source.length;
+
+  const previous = Array.from(
+    { length: target.length + 1 },
+    (_, index) => index,
+  );
+  const current = new Array<number>(target.length + 1);
+
+  for (let sourceIndex = 1; sourceIndex <= source.length; sourceIndex += 1) {
+    current[0] = sourceIndex;
+    const sourceCode = source.charCodeAt(sourceIndex - 1);
+
+    for (let targetIndex = 1; targetIndex <= target.length; targetIndex += 1) {
+      const replaceCost =
+        sourceCode === target.charCodeAt(targetIndex - 1) ? 0 : 1;
+      current[targetIndex] = Math.min(
+        previous[targetIndex] + 1,
+        current[targetIndex - 1] + 1,
+        previous[targetIndex - 1] + replaceCost,
+      );
+    }
+
+    for (let index = 0; index < current.length; index += 1) {
+      previous[index] = current[index];
+    }
+  }
+
+  return previous[target.length];
+}
+
+function getCommonPrefixLength(source: string, target: string): number {
+  const limit = Math.min(source.length, target.length);
+  let index = 0;
+
+  while (
+    index < limit &&
+    source.charCodeAt(index) === target.charCodeAt(index)
+  ) {
+    index += 1;
+  }
+
+  return index;
+}
+
+function isBetterMatch(
+  bestMatch: string | undefined,
+  bestDistance: number,
+  bestPrefixLength: number,
+  candidateKey: string,
+  candidateDistance: number,
+  candidatePrefixLength: number,
+): boolean {
+  return (
+    candidateDistance < bestDistance ||
+    (candidateDistance === bestDistance &&
+      candidatePrefixLength > bestPrefixLength) ||
+    (candidateDistance === bestDistance &&
+      candidatePrefixLength === bestPrefixLength &&
+      (!bestMatch || candidateKey < bestMatch))
+  );
+}
+
+export function findClosestTemplateKey(
+  type: string,
+  keys: Iterable<string>,
+): string | undefined {
+  const normalizedType = normalizeTemplateKey(type);
+  if (!normalizedType) return undefined;
+
+  let bestMatch: string | undefined;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  let bestPrefixLength = -1;
+
+  for (const key of keys) {
+    const normalizedKey = normalizeTemplateKey(key);
+    if (normalizedKey === normalizedType) {
+      return key;
+    }
+
+    const distance = getLevenshteinDistance(normalizedType, normalizedKey);
+    const prefixLength = getCommonPrefixLength(normalizedType, normalizedKey);
+
+    if (
+      isBetterMatch(
+        bestMatch,
+        bestDistance,
+        bestPrefixLength,
+        key,
+        distance,
+        prefixLength,
+      )
+    ) {
+      bestMatch = key;
+      bestDistance = distance;
+      bestPrefixLength = prefixLength;
+    }
+  }
+
+  return bestMatch;
+}

package/src/themes/built-in.ts

@@ -1,5 +1,9 @@
 import { registerTheme } from './registry';
 
+registerTheme('light', {
+  colorBg: '#ffffff',
+});
+
 registerTheme('dark', {
   colorBg: '#1F1F1F',
   base: {

package/src/utils/padding.ts

@@ -27,7 +27,7 @@ export function setSVGPadding(svg: SVGSVGElement, padding: ParsedPadding) {
   if (isNode) {
     setSVGPaddingInNode(svg, padding);
   } else {
-    if (document.contains(svg)) {
+    if (svg.isConnected) {
       setSVGPaddingInBrowser(svg, padding);
     } else {
       try {

package/src/utils/style.ts

@@ -1,8 +1,35 @@
-export function injectStyleOnce(id: string, styles: string) {
-  if (document.getElementById(id)) return;
+type StyleTarget = Document | ShadowRoot | Node | null | undefined;
 
-  const style = document.createElement('style');
+function resolveStyleRoot(target?: StyleTarget): Document | ShadowRoot {
+  if (!target) return document;
+  if (target instanceof Document || target instanceof ShadowRoot) return target;
+  if (!target.isConnected) return document;
+
+  const root = target.getRootNode();
+  return root instanceof ShadowRoot ? root : document;
+}
+
+function hasStyle(root: Document | ShadowRoot, id: string) {
+  if (root instanceof Document) return Boolean(root.getElementById(id));
+  return Boolean(root.querySelector(`#${id}`));
+}
+
+export function injectStyleOnce(
+  id: string,
+  styles: string,
+  target?: StyleTarget,
+) {
+  const root = resolveStyleRoot(target);
+  if (hasStyle(root, id)) return;
+
+  const doc = root instanceof Document ? root : (root.ownerDocument ?? document);
+  const style = doc.createElement('style');
   style.id = id;
   style.textContent = styles;
-  document.head.appendChild(style);
+
+  if (root instanceof Document) {
+    root.head.appendChild(style);
+  } else {
+    root.appendChild(style);
+  }
 }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.2.16';
+export const VERSION = '0.2.18';