@unocss/autocomplete 0.58.8 → 0.59.0-beta.1

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@unocss/autocomplete",
-  "version": "0.58.8",
+  "type": "module",
+  "version": "0.59.0-beta.1",
   "description": "Autocomplete utils for UnoCSS",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -21,12 +22,11 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
     }
   },
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
@@ -37,7 +37,7 @@
     "lru-cache": "^10.2.0"
   },
   "devDependencies": {
-    "@unocss/core": "0.58.8"
+    "@unocss/core": "0.59.0-beta.1"
   },
   "scripts": {
     "build": "unbuild",

package/dist/index.cjs

@@ -1,371 +0,0 @@
-'use strict';
-
-const core = require('@unocss/core');
-const lruCache = require('lru-cache');
-const fzf = require('fzf');
-
-function searchUsageBoundary(line, index) {
-  let start = index;
-  let end = index;
-  const regex = /[^\s>"'`;]/;
-  while (start && regex.test(line.charAt(start - 1)))
-    --start;
-  while (end < line.length && regex.test(line.charAt(end)))
-    ++end;
-  return {
-    content: line.slice(start, end),
-    start,
-    end
-  };
-}
-function searchAttrKey(content, cursor) {
-  const text = content.substring(0, cursor);
-  if (/(<\w+\s*)[^>]*$/.test(text))
-    return text.match(/\S+(?=\s*=\s*["']?[^"']*$)/)?.[0];
-}
-function cartesian(arr) {
-  return arr.reduce(
-    (a, b) => {
-      const ret = [];
-      a.forEach((a2) => {
-        b.forEach((b2) => {
-          ret.push(a2.concat([b2]));
-        });
-      });
-      return ret;
-    },
-    [[]]
-  );
-}
-
-const shorthands = {
-  directions: "(x|y|t|b|l|r|s|e)",
-  num: `(${[0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 24, 36].join("|")})`,
-  percent: `(${[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100].join("|")})`,
-  percentage: `(${["10%", "20%", "30%", "40%", "50%", "60%", "70%", "80%", "90%", "100%"].join("|")})`
-};
-const ignoredThemeKeys = ["DEFAULT"];
-function handleRegexMatch(str, regex, onMatched, onNotMatched) {
-  let lastIndex = 0;
-  Array.from(str.matchAll(regex)).forEach((m) => {
-    const index = m.index;
-    if (lastIndex !== index)
-      onNotMatched(str.slice(lastIndex, index), lastIndex, index);
-    onMatched(m);
-    lastIndex = index + m[0].length;
-  });
-  if (lastIndex !== str.length)
-    onNotMatched(str.slice(lastIndex), lastIndex, str.length);
-}
-function parseAutocomplete(template, theme = {}, extraShorthands = {}) {
-  const parts = [];
-  const newShorthands = {
-    ...shorthands,
-    ...extraShorthands
-  };
-  template = template.replace(/<(\w+)>/g, (_, key) => {
-    if (!newShorthands[key])
-      throw new Error(`Unknown template shorthand: ${key}`);
-    return newShorthands[key];
-  });
-  handleGroups(template);
-  const fzf$1 = new fzf.Fzf(getAllCombination(parts));
-  return {
-    parts,
-    suggest
-  };
-  function handleNonGroup(input) {
-    handleRegexMatch(
-      input,
-      /\$([\w\.\|]+)/g,
-      (m) => {
-        parts.push({
-          type: "theme",
-          objects: m[1].split("|").map((i) => {
-            return i.split(".").reduce((v, k) => {
-              if (!k || !v[k])
-                throw new Error(`Invalid theme key ${k}`);
-              return v[k];
-            }, theme);
-          })
-        });
-      },
-      (str) => {
-        parts.push({
-          type: "static",
-          value: str
-        });
-      }
-    );
-  }
-  function handleGroups(input) {
-    handleRegexMatch(
-      input,
-      /\((.*?)\)/g,
-      (m) => {
-        parts.push({
-          type: "group",
-          values: m[1].split("|")
-        });
-      },
-      (str) => {
-        handleNonGroup(str);
-      }
-    );
-  }
-  function suggest(input, matchType = "prefix") {
-    if (input.length > 1 && matchType === "fuzzy")
-      return fzf$1.find(input).map((i) => i.item);
-    let rest = input.replace(/-/g, "");
-    let matched = [""];
-    let combinations = [""];
-    const tempParts = [...parts];
-    while (tempParts.length) {
-      const part = tempParts.shift();
-      if (part.type === "static") {
-        const temp = part.value.replace(/-/g, "");
-        if (!rest.startsWith(temp) && !part.value.startsWith(rest))
-          return [""];
-        matched = matched.map((m) => m + part.value);
-        rest = rest.slice(temp.length);
-      } else if (part.type === "group") {
-        const fullMatched = part.values.find((i) => i && rest.startsWith(i));
-        if (fullMatched) {
-          matched = matched.map((m) => m + fullMatched);
-          rest = rest.slice(fullMatched.length);
-          if (!tempParts[0] && rest)
-            return [];
-          continue;
-        } else {
-          if (tempParts[0]) {
-            const values = part.values.filter((i) => i && i.startsWith(rest));
-            rest = "";
-            if (values.length) {
-              matched = matched.map((m) => values.map((n) => m + n)).flat();
-              continue;
-            }
-            break;
-          }
-          if (matched[0] === "")
-            break;
-          combinations = part.values.filter((p) => p.startsWith(rest));
-          break;
-        }
-      } else if (part.type === "theme") {
-        const keys = part.objects.flatMap((i) => Object.keys(i)).filter((i) => i && !ignoredThemeKeys.includes(i) && i[0] !== "_");
-        const fullMatched = keys.find((i) => i && rest.startsWith(i));
-        if (fullMatched != null) {
-          rest = rest.slice(fullMatched.length);
-          const subObjects = part.objects.map((i) => i[fullMatched]).filter((i) => !!i && typeof i === "object");
-          if (subObjects.length) {
-            matched = matched.map((m) => `${m + fullMatched}-`);
-            tempParts.unshift({
-              type: "theme",
-              objects: subObjects
-            });
-          } else {
-            combinations = keys.filter((i) => i.startsWith(rest));
-          }
-        } else {
-          if (tempParts[0] && tempParts[0].type !== "static") {
-            const values = tempParts[0].values;
-            if (values)
-              matched = matched.filter((i) => i && rest.startsWith(i)).map((m) => values.map((n) => m + n)).flat();
-          } else {
-            combinations = keys.filter((i) => i.startsWith(rest));
-          }
-          break;
-        }
-      }
-    }
-    return combinations.map((i) => matched.map((m) => m + i)).flat().filter((i) => i.length >= input.length);
-  }
-}
-function getValuesFromPartTemplate(part) {
-  if (part.type === "static")
-    return [part.value];
-  if (part.type === "theme") {
-    return part.objects.flatMap((i) => {
-      const keys = Object.keys(i).filter((i2) => i2 && i2[0] !== "_");
-      for (const key in i) {
-        const value = i[key];
-        if (value === null || value === void 0)
-          continue;
-        if (typeof value === "object" && !Array.isArray(value)) {
-          const subKeys = getValuesFromPartTemplate({
-            type: "theme",
-            objects: [value]
-          }).map((i2) => `${key}-${i2}`);
-          keys.push(...subKeys);
-        }
-      }
-      return keys;
-    });
-  }
-  if (part.type === "group")
-    return [...part.values];
-  return [];
-}
-function getAllCombination(parts) {
-  const values = parts.map((i) => getValuesFromPartTemplate(i));
-  const list = core.uniq(cartesian(values).flatMap((i) => i.join("").replace("-DEFAULT", "")));
-  return list;
-}
-
-function createAutocomplete(uno, options = {}) {
-  const templateCache = /* @__PURE__ */ new Map();
-  const cache = new lruCache.LRUCache({ max: 5e3 });
-  let staticUtils = [];
-  const templates = [];
-  const matchType = options.matchType ?? "prefix";
-  reset();
-  return {
-    suggest,
-    suggestInFile,
-    templates,
-    cache,
-    reset,
-    /**
-     * Enumerate possible suggestions from 'aa' - 'zz'
-     */
-    enumerate
-  };
-  async function enumerate() {
-    const matched = /* @__PURE__ */ new Set();
-    const a2z = Array.from("abcdefghijklmnopqrstuvwxyz");
-    const a2zd = [...a2z, "-"];
-    const keys = a2z.flatMap((i) => [
-      i,
-      ...a2zd.map((j) => `${i}${j}`)
-    ]);
-    await Promise.all(
-      keys.map((key) => suggest(key).then((i) => i.forEach((j) => matched.add(j))))
-    );
-    await Promise.all(
-      [...matched].filter((i) => /^\w+$/.test(i) && i.length > 3).map((i) => suggest(`${i}-`).then((i2) => i2.forEach((j) => matched.add(j))))
-    );
-    return matched;
-  }
-  function getParsed(template) {
-    if (!templateCache.has(template))
-      templateCache.set(template, parseAutocomplete(template, uno.config.theme, uno.config.autocomplete.shorthands));
-    return templateCache.get(template).suggest;
-  }
-  async function suggest(input, allowsEmptyInput = false) {
-    if (!allowsEmptyInput && input.length < 1)
-      return [];
-    if (cache.has(input))
-      return cache.get(input);
-    const [, processed, , variants] = await uno.matchVariants(input);
-    let idx = processed ? input.search(core.escapeRegExp(processed)) : input.length;
-    if (idx === -1)
-      idx = 0;
-    const variantPrefix = input.slice(0, idx);
-    const variantSuffix = input.slice(idx + input.length);
-    let result = processSuggestions(
-      await Promise.all([
-        suggestSelf(processed),
-        suggestStatic(processed),
-        suggestUnoCache(processed),
-        ...suggestFromPreset(processed),
-        ...suggestVariant(processed, variants)
-      ]),
-      variantPrefix,
-      variantSuffix
-    );
-    if (matchType === "fuzzy") {
-      const fzf$1 = new fzf.Fzf(result, {
-        tiebreakers: [fzf.byStartAsc, fzf.byLengthAsc]
-      });
-      result = fzf$1.find(input).map((i) => i.item);
-    }
-    cache.set(input, result);
-    return result;
-  }
-  async function suggestInFile(content, cursor) {
-    const isInsideAttrValue = searchAttrKey(content, cursor) !== void 0;
-    const byExtractor = await searchUsageByExtractor(content, cursor);
-    if (byExtractor) {
-      const suggestions2 = await suggest(byExtractor.extracted, isInsideAttrValue);
-      const formatted = byExtractor.transformSuggestions ? byExtractor.transformSuggestions(suggestions2) : suggestions2;
-      return {
-        suggestions: suggestions2.map((v, i) => [v, formatted[i]]),
-        resolveReplacement: byExtractor.resolveReplacement
-      };
-    }
-    const regular = searchUsageBoundary(content, cursor);
-    const suggestions = await suggest(regular.content, isInsideAttrValue);
-    return {
-      suggestions: suggestions.map((v) => [v, v]),
-      resolveReplacement: (suggestion) => ({
-        start: regular.start,
-        end: regular.end,
-        replacement: suggestion
-      })
-    };
-  }
-  async function searchUsageByExtractor(content, cursor) {
-    if (!uno.config.autocomplete.extractors.length)
-      return null;
-    for (const extractor of uno.config.autocomplete.extractors) {
-      const res = await extractor.extract({ content, cursor });
-      if (res)
-        return res;
-    }
-    return null;
-  }
-  async function suggestSelf(input) {
-    const i = await uno.parseToken(input, "-");
-    return i ? [input] : [];
-  }
-  async function suggestStatic(input) {
-    if (matchType === "fuzzy")
-      return staticUtils;
-    return staticUtils.filter((i) => i.startsWith(input));
-  }
-  async function suggestUnoCache(input) {
-    const keys = Array.from(uno._cache.entries());
-    return keys.filter((i) => i[1] && i[0].startsWith(input)).map((i) => i[0]);
-  }
-  function suggestFromPreset(input) {
-    return templates.map((fn) => typeof fn === "function" ? fn(input) : getParsed(fn)(input, matchType)) || [];
-  }
-  function suggestVariant(input, used) {
-    return uno.config.variants.filter((v) => v.autocomplete && (v.multiPass || !used.has(v))).flatMap((v) => core.toArray(v.autocomplete || [])).map((fn) => typeof fn === "function" ? fn(input) : getParsed(fn)(input, matchType));
-  }
-  function reset() {
-    templateCache.clear();
-    cache.clear();
-    staticUtils = [
-      ...Object.keys(uno.config.rulesStaticMap),
-      ...uno.config.shortcuts.filter((i) => typeof i[0] === "string").map((i) => i[0])
-    ];
-    templates.length = 0;
-    templates.push(
-      ...uno.config.autocomplete.templates || [],
-      ...uno.config.rulesDynamic.flatMap((i) => core.toArray(i?.[3]?.autocomplete || [])),
-      ...uno.config.shortcuts.flatMap((i) => core.toArray(i?.[2]?.autocomplete || []))
-    );
-  }
-  function processSuggestions(suggestions, prefix = "", suffix = "") {
-    return core.uniq(suggestions.flat()).filter((i) => !!(i && !i.endsWith("-") && !uno.isBlocked(i))).sort((a, b) => {
-      if (/\d/.test(a) && /\D/.test(b))
-        return 1;
-      if (/\D/.test(a) && /\d/.test(b))
-        return -1;
-      const numA = +(a.match(/\d+$/)?.[0] || Number.NaN);
-      const numB = +(b.match(/\d+$/)?.[0] || Number.NaN);
-      if (!Number.isNaN(numA) && !Number.isNaN(numB))
-        return numA - numB;
-      return a.localeCompare(b);
-    }).map((i) => prefix + i + suffix);
-  }
-}
-
-exports.cartesian = cartesian;
-exports.createAutocomplete = createAutocomplete;
-exports.ignoredThemeKeys = ignoredThemeKeys;
-exports.parseAutocomplete = parseAutocomplete;
-exports.searchAttrKey = searchAttrKey;
-exports.searchUsageBoundary = searchUsageBoundary;
-exports.shorthands = shorthands;

package/dist/index.d.cts

@@ -1,48 +0,0 @@
-import { SuggestResult, AutoCompleteFunction, UnoGenerator } from '@unocss/core';
-import { LRUCache } from 'lru-cache';
-
-type AutoCompleteMatchType = 'prefix' | 'fuzzy';
-interface AutocompleteOptions {
-    matchType?: AutoCompleteMatchType;
-}
-type AutocompleteTemplatePart = AutocompleteTemplateStatic | AutocompleteTemplateGroup | AutocompleteTemplateTheme;
-interface AutocompleteTemplateStatic {
-    type: 'static';
-    value: string;
-}
-interface AutocompleteTemplateGroup {
-    type: 'group';
-    values: string[];
-}
-interface AutocompleteTemplateTheme {
-    type: 'theme';
-    objects: Record<string, unknown>[];
-}
-interface ParsedAutocompleteTemplate {
-    parts: AutocompleteTemplatePart[];
-    suggest: (input: string, matchType?: AutoCompleteMatchType) => string[] | undefined;
-}
-interface UnocssAutocomplete {
-    suggest: (input: string, allowsEmptyInput?: boolean) => Promise<string[]>;
-    suggestInFile: (content: string, cursor: number) => Promise<SuggestResult>;
-    templates: (string | AutoCompleteFunction)[];
-    cache: LRUCache<string, string[]>;
-    reset: () => void;
-    enumerate: () => Promise<Set<string>>;
-}
-
-declare function createAutocomplete(uno: UnoGenerator, options?: AutocompleteOptions): UnocssAutocomplete;
-
-declare const shorthands: Record<string, string>;
-declare const ignoredThemeKeys: string[];
-declare function parseAutocomplete(template: string, theme?: any, extraShorthands?: Record<string, string>): ParsedAutocompleteTemplate;
-
-declare function searchUsageBoundary(line: string, index: number): {
-    content: string;
-    start: number;
-    end: number;
-};
-declare function searchAttrKey(content: string, cursor: number): string | undefined;
-declare function cartesian<T>(arr: T[][]): T[][];
-
-export { type AutoCompleteMatchType, type AutocompleteOptions, type AutocompleteTemplateGroup, type AutocompleteTemplatePart, type AutocompleteTemplateStatic, type AutocompleteTemplateTheme, type ParsedAutocompleteTemplate, type UnocssAutocomplete, cartesian, createAutocomplete, ignoredThemeKeys, parseAutocomplete, searchAttrKey, searchUsageBoundary, shorthands };