@opendesign-plus/components 0.0.1-rc.5 → 0.0.1-rc.50

package/dist/treeshaking/components/search/OSearchInput.vue.mjs

@@ -0,0 +1,7 @@
+import _sfc_main from "./OSearchInput.vue2.mjs";
+import './OSearchInput.css';
+import _export_sfc from "../../_virtual/_plugin-vue_export-helper.mjs";
+const _OSearchInput = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-18e8aec0"]]);
+export {
+  _OSearchInput as default
+};

package/dist/treeshaking/components/search/OSearchInput.vue2.mjs

@@ -0,0 +1,382 @@
+import { defineComponent, ref, computed, toRef, watch, openBlock, createElementBlock, normalizeClass, createElementVNode, createVNode, createSlots, withCtx, renderSlot, normalizeProps, guardReactiveProps, Transition, unref, createCommentVNode, toDisplayString, Fragment, renderList, createTextVNode } from "vue";
+import { useDebounceFn, onClickOutside } from "@vueuse/core";
+import SearchImageInput from "./internal/SearchImageInput.vue.mjs";
+import SearchPanel from "./internal/SearchPanel.vue.mjs";
+import { useSearchHistory } from "./composables/useSearchHistory.mjs";
+import { useI18n } from "../../i18n/index.mjs";
+const _hoisted_1 = { class: "o-search-input-box" };
+const _hoisted_2 = {
+  key: 0,
+  class: "o-search-input-dropdown"
+};
+const _hoisted_3 = {
+  key: 0,
+  class: "o-search-input-suggest-list-row"
+};
+const _hoisted_4 = { class: "o-search-input-suggest-list-label" };
+const _hoisted_5 = { class: "o-search-input-suggest-list" };
+const _hoisted_6 = ["onClick"];
+const _hoisted_7 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "OSearchInput",
+  props: {
+    modelValue: { default: "" },
+    imageUrl: { default: "" },
+    size: { default: "large" },
+    placeholder: {},
+    imagePlaceholder: {},
+    enableImageSearch: { type: Boolean, default: false },
+    uploadImage: {},
+    maxImageSize: { default: 10 * 1024 * 1024 },
+    imageUploadTooltip: {},
+    allowedImageTypes: {},
+    suggestItems: { default: () => [] },
+    onestepItems: { default: () => [] },
+    suggestTitle: {},
+    onestepTitle: {},
+    noDataText: {},
+    showSuggestEmpty: { type: Boolean, default: true },
+    highlightKeyword: { type: Boolean, default: true },
+    debounce: { default: 300 },
+    enableHistory: { type: Boolean, default: true },
+    historyItems: { default: () => [] },
+    maxHistoryCount: { default: 6 },
+    storeHistory: { type: Boolean, default: false },
+    storageKey: { default: "search-history" },
+    historyTitle: {},
+    autoSaveHistory: { type: Boolean, default: true },
+    hotItems: { default: () => [] },
+    hotTitle: {},
+    suggestList: { default: () => [] },
+    suggestListLabel: {},
+    clearable: { type: Boolean, default: true },
+    closeOnSearch: { type: Boolean, default: true },
+    closeOnClickOutside: { type: Boolean, default: true },
+    openOnFocus: { type: Boolean, default: true },
+    alwaysInlineThumbnail: { type: Boolean }
+  },
+  emits: ["update:modelValue", "update:imageUrl", "update:historyItems", "focus", "blur", "input", "clear", "search", "recommend-click", "onestep-click", "history-click", "hot-click", "suggest-list-click", "delete-history", "delete-history-item", "image-upload-start", "image-upload-success", "image-upload-error", "image-validate-error"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { t } = useI18n();
+    function parseSuggest(raw) {
+      const segments = [];
+      const re = /<em>(.*?)<\/em>/g;
+      let last = 0;
+      let m;
+      while ((m = re.exec(raw)) !== null) {
+        if (m.index > last) segments.push({ text: raw.slice(last, m.index), em: false });
+        segments.push({ text: m[1], em: true });
+        last = m.index + m[0].length;
+      }
+      if (last < raw.length) segments.push({ text: raw.slice(last), em: false });
+      return segments;
+    }
+    const inputRef = ref();
+    const wrapperRef = ref(null);
+    const innerValue = computed({
+      get: () => props.modelValue,
+      set: (val) => emit("update:modelValue", val)
+    });
+    const isFocus = ref(false);
+    const isPreviewOpen = ref(false);
+    const justClosedPreview = ref(false);
+    const hasInternalImage = ref(false);
+    const showDropdown = computed(() => {
+      if (!isFocus.value) return false;
+      if (props.imageUrl || hasInternalImage.value) return false;
+      const hasSuggest = !!innerValue.value && (props.suggestItems.length > 0 || props.onestepItems.length > 0 || props.showSuggestEmpty);
+      const hasHistory = props.enableHistory && history.items.value.length > 0 && !innerValue.value;
+      const hasHot = props.hotItems.length > 0 && !innerValue.value;
+      if (hasSuggest) return true;
+      if (props.openOnFocus && (hasHistory || hasHot)) return true;
+      return false;
+    });
+    const historyItemsRef = toRef(props, "historyItems");
+    const storageKeyRef = toRef(props, "storageKey");
+    const storeHistoryRef = toRef(props, "storeHistory");
+    const maxHistoryRef = toRef(props, "maxHistoryCount");
+    const history = useSearchHistory({
+      initial: historyItemsRef,
+      storageKey: storageKeyRef,
+      storeHistory: storeHistoryRef,
+      maxHistoryCount: maxHistoryRef,
+      onChange: (items) => emit("update:historyItems", items)
+    });
+    let suppressNextInput = false;
+    const emitInputDebounced = useDebounceFn((val) => {
+      if (suppressNextInput) {
+        suppressNextInput = false;
+        return;
+      }
+      emit("input", val);
+    }, () => props.debounce);
+    watch(innerValue, (val) => {
+      emitInputDebounced(val);
+    });
+    onClickOutside(wrapperRef, () => {
+      if (!props.closeOnClickOutside) return;
+      if (isPreviewOpen.value || justClosedPreview.value) return;
+      isFocus.value = false;
+    });
+    const handleFocus = () => {
+      isFocus.value = true;
+      emit("focus");
+    };
+    const handleBlur = () => {
+      emit("blur");
+    };
+    const runSearch = async (overrideKeyword) => {
+      var _a, _b, _c, _d, _e, _f;
+      if ((_b = (_a = inputRef.value) == null ? void 0 : _a.getIsUploading) == null ? void 0 : _b.call(_a)) {
+        await ((_d = (_c = inputRef.value).awaitUpload) == null ? void 0 : _d.call(_c));
+      }
+      const keyword = overrideKeyword !== void 0 ? overrideKeyword.trim() : innerValue.value.trim();
+      const imageUrl = ((_f = (_e = inputRef.value) == null ? void 0 : _e.getUploadedUrl) == null ? void 0 : _f.call(_e)) || props.imageUrl;
+      if (!keyword && !imageUrl) return;
+      if (props.autoSaveHistory && keyword) {
+        history.push(keyword);
+      }
+      if (props.closeOnSearch) {
+        isFocus.value = false;
+      }
+      emit("search", { keyword, imageUrl: imageUrl || void 0 });
+    };
+    const handleClear = () => {
+      innerValue.value = "";
+      emit("clear");
+    };
+    const handleSuggestClick = (item) => {
+      emit("recommend-click", item);
+      suppressNextInput = true;
+      innerValue.value = item.key;
+      runSearch(item.key ?? "");
+    };
+    const handleOnestepClick = (item) => {
+      emit("onestep-click", item);
+      if (item.path) {
+        const url = item.path;
+        if (typeof window !== "undefined") window.open(url, "_blank", "noopener,noreferrer");
+      }
+    };
+    const handleHistoryClick = (val) => {
+      emit("history-click", val);
+      runSearch(val);
+    };
+    const handleHotClick = (val) => {
+      emit("hot-click", val);
+      runSearch(val);
+    };
+    const handleHistoryRemove = (val) => {
+      history.remove(val);
+      emit("delete-history-item", val);
+    };
+    const handleHistoryClear = () => {
+      const removed = [...history.items.value];
+      history.clearAll();
+      emit("delete-history", removed);
+    };
+    const handleSuggestListClick = (val) => {
+      const text = val.replace(/<[^>]+>/g, "");
+      emit("suggest-list-click", text);
+      suppressNextInput = true;
+      innerValue.value = text;
+      runSearch(text);
+    };
+    const onPreviewChange = (visible) => {
+      isPreviewOpen.value = visible;
+      if (!visible) {
+        justClosedPreview.value = true;
+        setTimeout(() => {
+          justClosedPreview.value = false;
+        }, 100);
+      }
+    };
+    const showInlineThumbnail = computed(
+      () => !!props.imageUrl && (props.alwaysInlineThumbnail || !isFocus.value)
+    );
+    const onImageUploadStart = (file) => {
+      hasInternalImage.value = true;
+      emit("image-upload-start", file);
+    };
+    const onImageUploadSuccess = (url, file) => {
+      hasInternalImage.value = false;
+      emit("image-upload-success", url, file);
+    };
+    const onImageClear = () => {
+      hasInternalImage.value = false;
+      emit("update:imageUrl", "");
+    };
+    __expose({
+      focus: () => {
+        var _a, _b;
+        return (_b = (_a = inputRef.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
+      },
+      blur: () => {
+        var _a, _b;
+        return (_b = (_a = inputRef.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
+      },
+      search: runSearch,
+      saveHistory: (val) => history.push(val ?? innerValue.value)
+    });
+    return (_ctx, _cache) => {
+      var _a;
+      return openBlock(), createElementBlock("div", {
+        ref_key: "wrapperRef",
+        ref: wrapperRef,
+        class: normalizeClass(["o-search-input", { "is-focus": isFocus.value }])
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          createVNode(SearchImageInput, {
+            ref_key: "inputRef",
+            ref: inputRef,
+            modelValue: innerValue.value,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => innerValue.value = $event),
+            "image-url": __props.imageUrl,
+            placeholder: __props.placeholder,
+            "image-placeholder": __props.imagePlaceholder,
+            size: __props.size,
+            "enable-image-search": __props.enableImageSearch,
+            "upload-image": __props.uploadImage,
+            "max-image-size": __props.maxImageSize,
+            "image-upload-tooltip": __props.imageUploadTooltip,
+            "allowed-image-types": __props.allowedImageTypes,
+            expanded: isFocus.value && !props.alwaysInlineThumbnail,
+            "inline-thumbnail": showInlineThumbnail.value,
+            clearable: __props.clearable,
+            class: "o-search-input-field",
+            "onUpdate:imageUrl": _cache[1] || (_cache[1] = (url) => emit("update:imageUrl", url)),
+            onFocus: handleFocus,
+            onBlur: handleBlur,
+            onEnter: runSearch,
+            onClear: handleClear,
+            onImageClear,
+            onImageUploadStart,
+            onImageUploadSuccess,
+            onImageUploadError: _cache[2] || (_cache[2] = (error, file) => emit("image-upload-error", error, file)),
+            onImageValidateError: _cache[3] || (_cache[3] = (reason, file) => emit("image-validate-error", reason, file)),
+            onPreviewChange
+          }, createSlots({
+            prefix: withCtx(() => [
+              renderSlot(_ctx.$slots, "input-prefix", {}, void 0, true)
+            ]),
+            suffix: withCtx((slotProps) => [
+              renderSlot(_ctx.$slots, "input-suffix", normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+            ]),
+            _: 2
+          }, [
+            _ctx.$slots["image-preview"] ? {
+              name: "preview",
+              fn: withCtx((slotProps) => [
+                renderSlot(_ctx.$slots, "image-preview", normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+              ]),
+              key: "0"
+            } : void 0
+          ]), 1032, ["modelValue", "image-url", "placeholder", "image-placeholder", "size", "enable-image-search", "upload-image", "max-image-size", "image-upload-tooltip", "allowed-image-types", "expanded", "inline-thumbnail", "clearable"]),
+          createVNode(Transition, { name: "o-search-input-dropdown" }, {
+            default: withCtx(() => [
+              showDropdown.value ? (openBlock(), createElementBlock("div", _hoisted_2, [
+                renderSlot(_ctx.$slots, "dropdown", { keyword: __props.modelValue }, () => [
+                  createVNode(SearchPanel, {
+                    keyword: __props.modelValue,
+                    "onestep-items": __props.onestepItems,
+                    "onestep-title": __props.onestepTitle,
+                    "suggest-items": __props.suggestItems,
+                    "suggest-title": __props.suggestTitle,
+                    "history-items": __props.enableHistory ? unref(history).items.value : [],
+                    "history-title": __props.historyTitle,
+                    "hot-items": __props.hotItems,
+                    "hot-title": __props.hotTitle,
+                    "no-data-text": __props.noDataText,
+                    "highlight-keyword": __props.highlightKeyword,
+                    "hide-on-keyword": true,
+                    "show-suggest-empty": __props.showSuggestEmpty,
+                    "history-layout": "list",
+                    onOnestepClick: handleOnestepClick,
+                    onSuggestClick: handleSuggestClick,
+                    onHistoryClick: handleHistoryClick,
+                    onHistoryRemove: handleHistoryRemove,
+                    onHistoryClear: handleHistoryClear,
+                    onHotClick: handleHotClick
+                  }, createSlots({ _: 2 }, [
+                    _ctx.$slots["onestep-header"] ? {
+                      name: "onestep-header",
+                      fn: withCtx((slotProps) => [
+                        renderSlot(_ctx.$slots, "onestep-header", normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+                      ]),
+                      key: "0"
+                    } : void 0,
+                    _ctx.$slots["onestep-content"] ? {
+                      name: "onestep-content",
+                      fn: withCtx((slotProps) => [
+                        renderSlot(_ctx.$slots, "onestep-content", normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+                      ]),
+                      key: "1"
+                    } : void 0,
+                    _ctx.$slots["suggest-header"] ? {
+                      name: "suggest-header",
+                      fn: withCtx((slotProps) => [
+                        renderSlot(_ctx.$slots, "suggest-header", normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+                      ]),
+                      key: "2"
+                    } : void 0,
+                    _ctx.$slots["suggest-content"] ? {
+                      name: "suggest-content",
+                      fn: withCtx((slotProps) => [
+                        renderSlot(_ctx.$slots, "suggest-content", normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+                      ]),
+                      key: "3"
+                    } : void 0,
+                    _ctx.$slots["history-header"] ? {
+                      name: "history-header",
+                      fn: withCtx((slotProps) => [
+                        renderSlot(_ctx.$slots, "history-header", normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+                      ]),
+                      key: "4"
+                    } : void 0,
+                    _ctx.$slots["history-content"] ? {
+                      name: "history-content",
+                      fn: withCtx((slotProps) => [
+                        renderSlot(_ctx.$slots, "history-content", normalizeProps(guardReactiveProps(slotProps)), void 0, true)
+                      ]),
+                      key: "5"
+                    } : void 0
+                  ]), 1032, ["keyword", "onestep-items", "onestep-title", "suggest-items", "suggest-title", "history-items", "history-title", "hot-items", "hot-title", "no-data-text", "highlight-keyword", "show-suggest-empty"])
+                ], true)
+              ])) : createCommentVNode("", true)
+            ]),
+            _: 3
+          })
+        ]),
+        ((_a = __props.suggestList) == null ? void 0 : _a.length) ? (openBlock(), createElementBlock("div", _hoisted_3, [
+          renderSlot(_ctx.$slots, "suggest-list", { items: __props.suggestList }, () => [
+            createElementVNode("span", _hoisted_4, toDisplayString(__props.suggestListLabel ?? unref(t)("search.suggestListLabel")), 1),
+            createElementVNode("ul", _hoisted_5, [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(__props.suggestList, (item, idx) => {
+                return openBlock(), createElementBlock("li", {
+                  key: item + idx,
+                  class: "o-search-input-suggest-list-item",
+                  onClick: ($event) => handleSuggestListClick(item)
+                }, [
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(parseSuggest(item), (seg) => {
+                    return openBlock(), createElementBlock(Fragment, {
+                      key: seg.text + String(seg.em)
+                    }, [
+                      seg.em ? (openBlock(), createElementBlock("em", _hoisted_7, toDisplayString(seg.text), 1)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+                        createTextVNode(toDisplayString(seg.text), 1)
+                      ], 64))
+                    ], 64);
+                  }), 128))
+                ], 8, _hoisted_6);
+              }), 128))
+            ])
+          ], true)
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/treeshaking/components/search/composables/useImageSearch.d.ts

@@ -0,0 +1,48 @@
+import { Ref } from 'vue';
+import { OSearchUploadImageFn } from '../types';
+export interface UseImageSearchOptions {
+    uploadImage?: Ref<OSearchUploadImageFn | undefined>;
+    maxImageSize: Ref<number>;
+    allowedImageTypes?: Ref<string[]>;
+    onUploadStart?: (file: File) => void;
+    onUploadSuccess?: (url: string, file: File) => void;
+    onUploadError?: (error: unknown, file: File) => void;
+    onValidationError?: (reason: 'size' | 'type', file: File) => void;
+}
+export declare function useImageSearch(options: UseImageSearchOptions): {
+    previewUrl: Ref<string, string>;
+    file: Ref<{
+        readonly lastModified: number;
+        readonly name: string;
+        readonly webkitRelativePath: string;
+        readonly size: number;
+        readonly type: string;
+        arrayBuffer: () => Promise<ArrayBuffer>;
+        bytes: () => Promise<Uint8Array>;
+        slice: (start?: number, end?: number, contentType?: string) => Blob;
+        stream: () => ReadableStream<Uint8Array>;
+        text: () => Promise<string>;
+    } | null, File | {
+        readonly lastModified: number;
+        readonly name: string;
+        readonly webkitRelativePath: string;
+        readonly size: number;
+        readonly type: string;
+        arrayBuffer: () => Promise<ArrayBuffer>;
+        bytes: () => Promise<Uint8Array>;
+        slice: (start?: number, end?: number, contentType?: string) => Blob;
+        stream: () => ReadableStream<Uint8Array>;
+        text: () => Promise<string>;
+    } | null>;
+    uploadedUrl: Ref<string, string>;
+    isUploading: Ref<boolean, boolean>;
+    onPaste: (event: ClipboardEvent) => void;
+    onDrop: (event: DragEvent) => void;
+    onDragOver: (event: DragEvent) => void;
+    onFileChange: (event: Event) => void;
+    pickFile: (input: HTMLInputElement | undefined) => void;
+    handleImageFile: (f: File) => void;
+    reset: () => void;
+    setExternalUrl: (url: string) => void;
+    awaitUpload: () => Promise<void>;
+};

package/dist/treeshaking/components/search/composables/useImageSearch.mjs

@@ -0,0 +1,134 @@
+import { ref, onBeforeUnmount } from "vue";
+function useImageSearch(options) {
+  const previewUrl = ref("");
+  const file = ref(null);
+  const uploadedUrl = ref("");
+  const isUploading = ref(false);
+  let uploadPromise = null;
+  const validate = (f) => {
+    var _a, _b, _c, _d;
+    const allowed = (_a = options.allowedImageTypes) == null ? void 0 : _a.value;
+    const typeOk = allowed && allowed.length > 0 ? allowed.includes(f.type) : (_b = f.type) == null ? void 0 : _b.startsWith("image/");
+    if (!f.type || !typeOk) {
+      (_c = options.onValidationError) == null ? void 0 : _c.call(options, "type", f);
+      return false;
+    }
+    if (options.maxImageSize.value > 0 && f.size > options.maxImageSize.value) {
+      (_d = options.onValidationError) == null ? void 0 : _d.call(options, "size", f);
+      return false;
+    }
+    return true;
+  };
+  const reset = () => {
+    if (previewUrl.value) {
+      try {
+        URL.revokeObjectURL(previewUrl.value);
+      } catch {
+      }
+    }
+    previewUrl.value = "";
+    file.value = null;
+    uploadedUrl.value = "";
+    isUploading.value = false;
+    uploadPromise = null;
+  };
+  const setExternalUrl = (url) => {
+    if (!url) {
+      if (!file.value) reset();
+      return;
+    }
+    if (uploadedUrl.value === url) return;
+    if (previewUrl.value && previewUrl.value.startsWith("blob:")) {
+      try {
+        URL.revokeObjectURL(previewUrl.value);
+      } catch {
+      }
+    }
+    uploadedUrl.value = url;
+    previewUrl.value = url;
+    file.value = null;
+  };
+  const handleImageFile = (f) => {
+    var _a, _b;
+    if (!validate(f)) return;
+    reset();
+    file.value = f;
+    previewUrl.value = URL.createObjectURL(f);
+    (_a = options.onUploadStart) == null ? void 0 : _a.call(options, f);
+    const fn = (_b = options.uploadImage) == null ? void 0 : _b.value;
+    if (!fn) {
+      return;
+    }
+    isUploading.value = true;
+    uploadPromise = Promise.resolve().then(() => fn(f)).then((url) => {
+      var _a2;
+      if (url && file.value === f) {
+        uploadedUrl.value = url;
+        (_a2 = options.onUploadSuccess) == null ? void 0 : _a2.call(options, url, f);
+      }
+    }).catch((err) => {
+      var _a2;
+      (_a2 = options.onUploadError) == null ? void 0 : _a2.call(options, err, f);
+    }).finally(() => {
+      isUploading.value = false;
+    });
+  };
+  const onPaste = (event) => {
+    var _a;
+    const items = (_a = event.clipboardData) == null ? void 0 : _a.items;
+    if (!items) return;
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      if (item.type.startsWith("image/")) {
+        const f = item.getAsFile();
+        if (f) handleImageFile(f);
+        break;
+      }
+    }
+  };
+  const onDragOver = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+  };
+  const onDrop = (event) => {
+    var _a, _b;
+    event.preventDefault();
+    event.stopPropagation();
+    const f = (_b = (_a = event.dataTransfer) == null ? void 0 : _a.files) == null ? void 0 : _b[0];
+    if (f && f.type.startsWith("image/")) {
+      handleImageFile(f);
+    }
+  };
+  const onFileChange = (event) => {
+    var _a;
+    const target = event.target;
+    const f = (_a = target.files) == null ? void 0 : _a[0];
+    if (f) handleImageFile(f);
+    if (target) target.value = "";
+  };
+  const pickFile = (input) => {
+    if (!input) return;
+    input.value = "";
+    input.click();
+  };
+  const awaitUpload = () => uploadPromise ?? Promise.resolve();
+  onBeforeUnmount(reset);
+  return {
+    previewUrl,
+    file,
+    uploadedUrl,
+    isUploading,
+    onPaste,
+    onDrop,
+    onDragOver,
+    onFileChange,
+    pickFile,
+    handleImageFile,
+    reset,
+    setExternalUrl,
+    awaitUpload
+  };
+}
+export {
+  useImageSearch
+};

package/dist/treeshaking/components/search/composables/useKeywordHighlight.d.ts

@@ -0,0 +1,2 @@
+import { OSearchHighlightPart } from '../types';
+export declare function highlightKeywordParts(text: string, keyword: string): OSearchHighlightPart[];

package/dist/treeshaking/components/search/composables/useKeywordHighlight.mjs

@@ -0,0 +1,28 @@
+const ESCAPE_RE = /[.*+?^${}()|[\]\\]/g;
+function highlightKeywordParts(text, keyword) {
+  const k = (keyword || "").trim();
+  if (!k) return [{ text, match: false }];
+  const escaped = k.replace(ESCAPE_RE, "\\$&");
+  const re = new RegExp(escaped, "gi");
+  const parts = [];
+  let lastIndex = 0;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    if (m.index === re.lastIndex) {
+      re.lastIndex++;
+      continue;
+    }
+    if (m.index > lastIndex) {
+      parts.push({ text: text.slice(lastIndex, m.index), match: false });
+    }
+    parts.push({ text: m[0], match: true });
+    lastIndex = m.index + m[0].length;
+  }
+  if (lastIndex < text.length) {
+    parts.push({ text: text.slice(lastIndex), match: false });
+  }
+  return parts;
+}
+export {
+  highlightKeywordParts
+};

package/dist/treeshaking/components/search/composables/useSearchHistory.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from 'vue';
+export interface UseSearchHistoryOptions {
+    initial: Ref<string[]>;
+    storageKey: Ref<string>;
+    storeHistory: Ref<boolean>;
+    maxHistoryCount: Ref<number>;
+    onChange?: (items: string[]) => void;
+}
+export declare function useSearchHistory(options: UseSearchHistoryOptions): {
+    items: Ref<string[], string[]>;
+    push: (val: string) => void;
+    remove: (val: string) => void;
+    clearAll: () => void;
+};

package/dist/treeshaking/components/search/composables/useSearchHistory.mjs

@@ -0,0 +1,58 @@
+import { ref, watch, onMounted } from "vue";
+function useSearchHistory(options) {
+  const { initial, storageKey, storeHistory, maxHistoryCount, onChange } = options;
+  const items = ref([...initial.value]);
+  const persist = () => {
+    if (!storeHistory.value || typeof localStorage === "undefined") return;
+    try {
+      if (items.value.length) {
+        localStorage.setItem(storageKey.value, JSON.stringify(items.value));
+      } else {
+        localStorage.removeItem(storageKey.value);
+      }
+    } catch {
+    }
+  };
+  const setItems = (next) => {
+    items.value = next;
+    persist();
+    onChange == null ? void 0 : onChange(items.value);
+  };
+  const loadFromStorage = () => {
+    if (!storeHistory.value || typeof localStorage === "undefined") return;
+    try {
+      const raw = localStorage.getItem(storageKey.value);
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed) && parsed.length) {
+        const merged = Array.from(/* @__PURE__ */ new Set([...parsed, ...items.value]));
+        items.value = merged.slice(0, maxHistoryCount.value);
+        onChange == null ? void 0 : onChange(items.value);
+      }
+    } catch {
+    }
+  };
+  const push = (val) => {
+    const v = val == null ? void 0 : val.trim();
+    if (!v) return;
+    const next = [v, ...items.value.filter((i) => i !== v)];
+    if (next.length > maxHistoryCount.value) next.length = maxHistoryCount.value;
+    setItems(next);
+  };
+  const remove = (val) => {
+    setItems(items.value.filter((i) => i !== val));
+  };
+  const clearAll = () => {
+    setItems([]);
+  };
+  watch(initial, (val) => {
+    if (val !== items.value) {
+      items.value = [...val];
+    }
+  });
+  onMounted(loadFromStorage);
+  return { items, push, remove, clearAll };
+}
+export {
+  useSearchHistory
+};