emoji-picker-react 5.1.0 → 5.1.2

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

@@ -0,0 +1,6 @@
+import { registerDefaultEmojiData } from "./chunk-V7DBC3DD.mjs";
+
+import { emojis_default } from "./chunk-ZOAKI5M6.mjs";
+
+// src/data/registerDefaultEmojiData.ts
+registerDefaultEmojiData(emojis_default);

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

@@ -0,0 +1,151 @@
+// src/data/defaultEmojiData.ts
+var registered = null;
+
+function registerDefaultEmojiData(data) {
+    registered = data;
+}
+
+function getRegisteredDefaultEmojiData() {
+    return registered;
+}
+
+var EMPTY_EMOJI_DATA = Object.freeze({
+    categories: {},
+    emojis: {}
+});
+
+function defaultEmojiDataOrEmpty() {
+    return registered ?? EMPTY_EMOJI_DATA;
+}
+
+var pending = null;
+
+function loadDefaultEmojiData() {
+    return registered ? Promise.resolve(registered) : (pending || (pending = import("./emojis-VTEL5M5C.mjs").then((module => {
+        const data = module.default ?? module;
+        return registered = registered ?? data;
+    })).catch((error => {
+        throw pending = null, error;
+    }))), pending);
+}
+
+// src/dataUtils/parseNativeEmoji.ts
+function parseNativeEmoji(unified) {
+    return String.fromCodePoint(...unified.split("-").map((hex => parseInt(hex, 16))));
+}
+
+// src/data-core/prepare.ts
+var coreCache = /* @__PURE__ */ new WeakMap, prepareCount = 0;
+
+function normalizeUnified(input) {
+    return input.trim().toLowerCase();
+}
+
+function withoutFe0f(unified) {
+    return unified.replace(/-fe0f/g, "");
+}
+
+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 id of [ unified, ...info.variations ]) byUnified.has(id) || byUnified.set(id, info), 
+    byUnified.has(withoutFe0f(id)) || byUnified.set(withoutFe0f(id), 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);
+    if (!normalized) return;
+    const core = getPreparedCore(options?.emojiData);
+    return core.byUnified.get(normalized) ?? core.byUnified.get(withoutFe0f(normalized));
+}
+
+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, parseNativeEmoji, withoutFe0f, normalizeQuery, getPreparedCore, getEmojiByUnified, searchEmojis };