@unocss/autocomplete 0.29.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @unocss/autocomplete
+
+Autocomplete utils for UnoCSS.
+
+> WIP
+
+## License
+
+MIT License © 2021-PRESENT [Anthony Fu](https://github.com/antfu)

package/dist/index.cjs

@@ -0,0 +1,187 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const core = require('@unocss/core');
+const LRU = require('lru-cache');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+const LRU__default = /*#__PURE__*/_interopDefaultLegacy(LRU);
+
+const shorthands = {
+  num: `(${[0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 24, 36].join("|")})`,
+  precent: `(${[0, 25, 50, 45, 100].join("|")})`,
+  directions: "(x|y|t|b|l|r|s|e)"
+};
+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 = {}) {
+  const parts = [];
+  template = template.replace(/<(\w+)>/g, (_, key) => {
+    if (!shorthands[key])
+      throw new Error(`Unknown template shorthand: ${key}`);
+    return shorthands[key];
+  });
+  handleGroups(template);
+  return {
+    parts,
+    suggest
+  };
+  function handleNonGroup(input) {
+    handleRegexMatch(input, /\$([\w\|]+)/g, (m) => {
+      const keys = m[1].split("|");
+      parts.push({
+        type: "theme",
+        objects: keys.map((i) => {
+          if (!i || !theme[i])
+            throw new Error(`Invalid theme key ${i}`);
+          return theme[i];
+        })
+      });
+    }, (str) => {
+      parts.push({
+        type: "static",
+        value: str
+      });
+    });
+  }
+  function handleGroups(input) {
+    handleRegexMatch(input, /\((.*?)\)/g, (m) => {
+      parts.push({
+        type: "group",
+        values: m[1].split("|").sort((a, b) => b.length - a.length)
+      });
+    }, (str) => {
+      handleNonGroup(str);
+    });
+  }
+  function suggest(input) {
+    let rest = input;
+    let matched = "";
+    let combinations = [];
+    const tempParts = [...parts];
+    while (tempParts.length) {
+      const part = tempParts.shift();
+      if (part.type === "static") {
+        if (!rest.startsWith(part.value))
+          break;
+        matched += part.value;
+        rest = rest.slice(part.value.length);
+      } else if (part.type === "group") {
+        const fullMatched = part.values.find((i) => i && rest.startsWith(i));
+        if (fullMatched != null) {
+          matched += fullMatched;
+          rest = rest.slice(fullMatched.length);
+        } else {
+          combinations = part.values.filter((i) => i.startsWith(rest));
+          break;
+        }
+      } else if (part.type === "theme") {
+        const keys = part.objects.flatMap((i) => Object.keys(i));
+        const fullMatched = keys.find((i) => i && rest.startsWith(i));
+        if (fullMatched != null) {
+          matched += fullMatched;
+          rest = rest.slice(fullMatched.length);
+          const subObjects = part.objects.map((i) => i[fullMatched]).filter((i) => !!i && typeof i === "object");
+          if (subObjects.length) {
+            tempParts.unshift({
+              type: "static",
+              value: "-"
+            }, {
+              type: "theme",
+              objects: subObjects
+            });
+          }
+        } else {
+          combinations = keys.filter((i) => i.startsWith(rest));
+          break;
+        }
+      }
+    }
+    if (!matched)
+      return [];
+    if (combinations.length === 0)
+      combinations.push("");
+    return combinations.map((i) => matched + i).filter((i) => i.length >= input.length);
+  }
+}
+
+function createAutocomplete(uno) {
+  const templateCache = /* @__PURE__ */ new Map();
+  const cache = new LRU__default({ max: 1e3 });
+  let staticUtils = [];
+  let templates = [];
+  function getParsed(template) {
+    if (!templateCache.has(template))
+      templateCache.set(template, parseAutocomplete(template, uno.config.theme));
+    return templateCache.get(template).suggest;
+  }
+  async function suggest(input) {
+    if (input.length < 2)
+      return [];
+    if (cache.has(input))
+      return cache.get(input);
+    const result = await Promise.all([
+      suggestSelf(input),
+      suggestStatic(input),
+      ...suggestFromPreset(input)
+    ]).then((i) => core.uniq(i.flat()).sort().filter(Boolean));
+    cache.set(input, result);
+    return result;
+  }
+  async function suggestSelf(input) {
+    const i = await uno.parseToken(input, "-");
+    return i ? [input] : [];
+  }
+  async function suggestStatic(input) {
+    return staticUtils.filter((i) => i.startsWith(input));
+  }
+  function suggestFromPreset(input) {
+    return templates.map((fn) => typeof fn === "function" ? fn(input) : getParsed(fn)(input)) || [];
+  }
+  function reset() {
+    templateCache.clear();
+    cache.clear();
+    staticUtils = Object.keys(uno.config.rulesStaticMap);
+    templates = [
+      ...uno.config.autocomplete || [],
+      ...uno.config.rulesDynamic.flatMap((i) => core.toArray(i?.[2]?.autocomplete || []))
+    ];
+  }
+  reset();
+  return {
+    suggest,
+    templates,
+    cache,
+    reset
+  };
+}
+
+function searchUsageBoundary(line, index) {
+  let start = index;
+  let end = index;
+  while (start && /[^\s"']/.test(line.charAt(start - 1)))
+    --start;
+  while (end < line.length && /[^\s"']/.test(line.charAt(end)))
+    ++end;
+  return {
+    content: line.slice(start, end),
+    start,
+    end
+  };
+}
+
+exports.createAutocomplete = createAutocomplete;
+exports.parseAutocomplete = parseAutocomplete;
+exports.searchUsageBoundary = searchUsageBoundary;

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { UnoGenerator, AutoCompleteFunction } from '@unocss/core';
+import LRU from 'lru-cache';
+
+declare function createAutocomplete(uno: UnoGenerator): {
+    suggest: (input: string) => Promise<string[] | undefined>;
+    templates: (string | AutoCompleteFunction)[];
+    cache: LRU<string, string[]>;
+    reset: () => void;
+};
+
+declare 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): string[] | undefined;
+}
+
+declare function parseAutocomplete(template: string, theme?: any): ParsedAutocompleteTemplate;
+
+declare function searchUsageBoundary(line: string, index: number): {
+    content: string;
+    start: number;
+    end: number;
+};
+
+export { AutocompleteTemplateGroup, AutocompleteTemplatePart, AutocompleteTemplateStatic, AutocompleteTemplateTheme, ParsedAutocompleteTemplate, createAutocomplete, parseAutocomplete, searchUsageBoundary };

package/dist/index.mjs

@@ -0,0 +1,177 @@
+import { uniq, toArray } from '@unocss/core';
+import LRU from 'lru-cache';
+
+const shorthands = {
+  num: `(${[0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 24, 36].join("|")})`,
+  precent: `(${[0, 25, 50, 45, 100].join("|")})`,
+  directions: "(x|y|t|b|l|r|s|e)"
+};
+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 = {}) {
+  const parts = [];
+  template = template.replace(/<(\w+)>/g, (_, key) => {
+    if (!shorthands[key])
+      throw new Error(`Unknown template shorthand: ${key}`);
+    return shorthands[key];
+  });
+  handleGroups(template);
+  return {
+    parts,
+    suggest
+  };
+  function handleNonGroup(input) {
+    handleRegexMatch(input, /\$([\w\|]+)/g, (m) => {
+      const keys = m[1].split("|");
+      parts.push({
+        type: "theme",
+        objects: keys.map((i) => {
+          if (!i || !theme[i])
+            throw new Error(`Invalid theme key ${i}`);
+          return theme[i];
+        })
+      });
+    }, (str) => {
+      parts.push({
+        type: "static",
+        value: str
+      });
+    });
+  }
+  function handleGroups(input) {
+    handleRegexMatch(input, /\((.*?)\)/g, (m) => {
+      parts.push({
+        type: "group",
+        values: m[1].split("|").sort((a, b) => b.length - a.length)
+      });
+    }, (str) => {
+      handleNonGroup(str);
+    });
+  }
+  function suggest(input) {
+    let rest = input;
+    let matched = "";
+    let combinations = [];
+    const tempParts = [...parts];
+    while (tempParts.length) {
+      const part = tempParts.shift();
+      if (part.type === "static") {
+        if (!rest.startsWith(part.value))
+          break;
+        matched += part.value;
+        rest = rest.slice(part.value.length);
+      } else if (part.type === "group") {
+        const fullMatched = part.values.find((i) => i && rest.startsWith(i));
+        if (fullMatched != null) {
+          matched += fullMatched;
+          rest = rest.slice(fullMatched.length);
+        } else {
+          combinations = part.values.filter((i) => i.startsWith(rest));
+          break;
+        }
+      } else if (part.type === "theme") {
+        const keys = part.objects.flatMap((i) => Object.keys(i));
+        const fullMatched = keys.find((i) => i && rest.startsWith(i));
+        if (fullMatched != null) {
+          matched += fullMatched;
+          rest = rest.slice(fullMatched.length);
+          const subObjects = part.objects.map((i) => i[fullMatched]).filter((i) => !!i && typeof i === "object");
+          if (subObjects.length) {
+            tempParts.unshift({
+              type: "static",
+              value: "-"
+            }, {
+              type: "theme",
+              objects: subObjects
+            });
+          }
+        } else {
+          combinations = keys.filter((i) => i.startsWith(rest));
+          break;
+        }
+      }
+    }
+    if (!matched)
+      return [];
+    if (combinations.length === 0)
+      combinations.push("");
+    return combinations.map((i) => matched + i).filter((i) => i.length >= input.length);
+  }
+}
+
+function createAutocomplete(uno) {
+  const templateCache = /* @__PURE__ */ new Map();
+  const cache = new LRU({ max: 1e3 });
+  let staticUtils = [];
+  let templates = [];
+  function getParsed(template) {
+    if (!templateCache.has(template))
+      templateCache.set(template, parseAutocomplete(template, uno.config.theme));
+    return templateCache.get(template).suggest;
+  }
+  async function suggest(input) {
+    if (input.length < 2)
+      return [];
+    if (cache.has(input))
+      return cache.get(input);
+    const result = await Promise.all([
+      suggestSelf(input),
+      suggestStatic(input),
+      ...suggestFromPreset(input)
+    ]).then((i) => uniq(i.flat()).sort().filter(Boolean));
+    cache.set(input, result);
+    return result;
+  }
+  async function suggestSelf(input) {
+    const i = await uno.parseToken(input, "-");
+    return i ? [input] : [];
+  }
+  async function suggestStatic(input) {
+    return staticUtils.filter((i) => i.startsWith(input));
+  }
+  function suggestFromPreset(input) {
+    return templates.map((fn) => typeof fn === "function" ? fn(input) : getParsed(fn)(input)) || [];
+  }
+  function reset() {
+    templateCache.clear();
+    cache.clear();
+    staticUtils = Object.keys(uno.config.rulesStaticMap);
+    templates = [
+      ...uno.config.autocomplete || [],
+      ...uno.config.rulesDynamic.flatMap((i) => toArray(i?.[2]?.autocomplete || []))
+    ];
+  }
+  reset();
+  return {
+    suggest,
+    templates,
+    cache,
+    reset
+  };
+}
+
+function searchUsageBoundary(line, index) {
+  let start = index;
+  let end = index;
+  while (start && /[^\s"']/.test(line.charAt(start - 1)))
+    --start;
+  while (end < line.length && /[^\s"']/.test(line.charAt(end)))
+    ++end;
+  return {
+    content: line.slice(start, end),
+    start,
+    end
+  };
+}
+
+export { createAutocomplete, parseAutocomplete, searchUsageBoundary };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@unocss/autocomplete",
+  "version": "0.29.0",
+  "description": "Autocomplete utils for UnoCSS",
+  "keywords": [
+    "unocss",
+    "autocomplete"
+  ],
+  "homepage": "https://github.com/unocss/unocss/tree/main/packages/autocomplete#readme",
+  "bugs": {
+    "url": "https://github.com/unocss/unocss/issues"
+  },
+  "license": "MIT",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unocss/unocss.git",
+    "directory": "packages/autocomplete"
+  },
+  "funding": "https://github.com/sponsors/antfu",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "lru-cache": "^7.5.1"
+  },
+  "devDependencies": {
+    "@types/lru-cache": "^7.4.0",
+    "@unocss/core": "0.29.0"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "stub": "unbuild --stub"
+  },
+  "readme": "# @unocss/autocomplete\n\nAutocomplete utils for UnoCSS.\n\n> WIP\n\n## License\n\nMIT License © 2021-PRESENT [Anthony Fu](https://github.com/antfu)\n"
+}