emoji-picker-react 5.0.0 → 5.0.1

package/dist/esm/chunks/chunk-ACXAQEKG.mjs

@@ -0,0 +1,149 @@
+import { __esm } from "./chunk-LO4TPPLH.mjs";
+
+// src/data/defaultEmojiData.ts
+function registerDefaultEmojiData(data) {
+    registered = data;
+}
+
+function getRegisteredDefaultEmojiData() {
+    return registered;
+}
+
+function defaultEmojiDataOrEmpty() {
+    return registered ?? EMPTY_EMOJI_DATA;
+}
+
+function loadDefaultEmojiData() {
+    return registered ? Promise.resolve(registered) : (pending || (pending = import("./emojis-6L3GRBAP.mjs").then((module => {
+        const data = module.default ?? module;
+        return registered = registered ?? data;
+    })).catch((error => {
+        throw pending = null, error;
+    }))), pending);
+}
+
+var registered, EMPTY_EMOJI_DATA, pending, init_defaultEmojiData = __esm({
+    "src/data/defaultEmojiData.ts"() {
+        registered = null, EMPTY_EMOJI_DATA = Object.freeze({
+            categories: {},
+            emojis: {}
+        }), pending = null;
+    }
+});
+
+// src/dataUtils/parseNativeEmoji.ts
+function parseNativeEmoji(unified) {
+    return String.fromCodePoint(...unified.split("-").map((hex => parseInt(hex, 16))));
+}
+
+// src/data-core/prepare.ts
+// src/data-core/prepare.ts
+init_defaultEmojiData();
+
+var coreCache = /* @__PURE__ */ new WeakMap, prepareCount = 0;
+
+function normalizeUnified(input) {
+    return input.trim().toLowerCase();
+}
+
+function normalizeQuery(input) {
+    return input && "string" == typeof input ? input.trim().toLowerCase() : "";
+}
+
+function readStringArray(raw) {
+    return Array.isArray(raw) ? raw.filter((value => "string" == typeof value)).map((value => value.toLowerCase())) : [];
+}
+
+function appendEntry(byUnified, byCharMutable, records, entry) {
+    const rawUnified = entry.u;
+    if ("string" != typeof rawUnified || 0 === rawUnified.length) return;
+    const unified = rawUnified.toLowerCase();
+    if (byUnified.has(unified)) return;
+    const names = readStringArray(entry.n), variations = readStringArray(entry.v), addedIn = String(entry.a ?? ""), info = Object.freeze({
+        unified,
+        emoji: parseNativeEmoji(unified),
+        name: names[names.length - 1] || "",
+        names: Object.freeze(names),
+        variations: Object.freeze(variations),
+        addedIn
+    });
+    records.push(info), byUnified.set(unified, info);
+    for (const variation of info.variations) byUnified.has(variation) || byUnified.set(variation, info);
+    indexCharBucket(byCharMutable, names, info);
+}
+
+function indexCharBucket(byCharMutable, names, info) {
+    for (const char of names.join("")) {
+        const bucket = byCharMutable.get(char);
+        bucket ? bucket[bucket.length - 1] !== info && bucket.push(info) : byCharMutable.set(char, [ info ]);
+    }
+}
+
+function getPreparedCore(emojiData) {
+    const source = emojiData ?? defaultEmojiDataOrEmpty(), cached = coreCache.get(source);
+    if (cached) return cached;
+    prepareCount += 1;
+    const byUnified = /* @__PURE__ */ new Map, byCharMutable = /* @__PURE__ */ new Map, records = [], groups = source.emojis ?? {};
+    for (const key of Object.keys(groups)) {
+        const list = groups[key] ?? [];
+        for (const entry of list) appendEntry(byUnified, byCharMutable, records, entry);
+    }
+    byCharMutable.forEach(Object.freeze);
+    const core = {
+        records,
+        byUnified,
+        byChar: byCharMutable,
+        queryMemo: /* @__PURE__ */ new Map
+    };
+    return coreCache.set(source, core), core;
+}
+
+// src/data-core/search.ts
+var EMPTY_RESULTS = Object.freeze([]), MAX_QUERY_MEMO_SIZE = 500;
+
+function memoizeQuery(core, normalized, results) {
+    const memo = core.queryMemo;
+    if (memo.has(normalized)) memo.delete(normalized); else if (memo.size >= MAX_QUERY_MEMO_SIZE) {
+        const oldest = memo.keys().next();
+        oldest.done || memo.delete(oldest.value);
+    }
+    memo.set(normalized, results);
+}
+
+function smallestCandidateBucket(core, normalized) {
+    let smallest = core.records;
+    for (const char of Array.from(normalized)) {
+        const bucket = core.byChar.get(char);
+        if (!bucket) return EMPTY_RESULTS;
+        bucket.length < smallest.length && (smallest = bucket);
+    }
+    return smallest;
+}
+
+function getEmojiByUnified(unified, options) {
+    if (!unified || "string" != typeof unified) return;
+    const normalized = normalizeUnified(unified);
+    return normalized ? getPreparedCore(options?.emojiData).byUnified.get(normalized) : void 0;
+}
+
+function searchEmojis(query, options) {
+    const normalized = normalizeQuery(query);
+    if (!normalized) return EMPTY_RESULTS;
+    const core = getPreparedCore(options?.emojiData), memoized = core.queryMemo.get(normalized);
+    if (memoized) return memoizeQuery(core, normalized, memoized), Object.freeze([ ...memoized ]);
+    if (1 === normalized.length) {
+        const bucket = core.byChar.get(normalized) ?? EMPTY_RESULTS;
+        return memoizeQuery(core, normalized, bucket), Object.freeze([ ...bucket ]);
+    }
+    const matches = [];
+    for (const record of smallestCandidateBucket(core, normalized)) {
+        const names = record.names;
+        for (let i = 0; i < names.length; i += 1) if (names[i].includes(normalized)) {
+            matches.push(record);
+            break;
+        }
+    }
+    return memoizeQuery(core, normalized, matches), Object.freeze([ ...matches ]);
+}
+
+export { registerDefaultEmojiData, getRegisteredDefaultEmojiData, EMPTY_EMOJI_DATA, defaultEmojiDataOrEmpty, loadDefaultEmojiData, init_defaultEmojiData, parseNativeEmoji, normalizeQuery, getPreparedCore, getEmojiByUnified, searchEmojis };