@yunfie/search-js 1.0.0

package/src/offline.ts

@@ -0,0 +1,44 @@
+// src/offline.ts
+import { emit } from "./events.js";
+
+type RetryTask = () => Promise<void>;
+
+const _pendingRetries: RetryTask[] = [];
+let _isOnline = true;
+let _initialized = false;
+
+export function getIsOnline(): boolean { return _isOnline; }
+
+export function initOfflineMonitor(): void {
+  if (_initialized || typeof window === "undefined") return;
+  _initialized = true;
+  _isOnline = navigator.onLine;
+  window.addEventListener("online",  _handleOnline);
+  window.addEventListener("offline", _handleOffline);
+}
+
+export function destroyOfflineMonitor(): void {
+  if (typeof window !== "undefined") {
+    window.removeEventListener("online",  _handleOnline);
+    window.removeEventListener("offline", _handleOffline);
+  }
+  _initialized = false;
+  _isOnline = true;
+  _pendingRetries.length = 0;
+}
+
+export function addRetryTask(task: RetryTask): void {
+  if (_pendingRetries.length < 50) _pendingRetries.push(task);
+}
+
+function _handleOnline(): void {
+  _isOnline = true;
+  emit("online");
+  const tasks = _pendingRetries.splice(0);
+  for (const task of tasks) task().catch(() => {});
+}
+
+function _handleOffline(): void {
+  _isOnline = false;
+  emit("offline");
+}

package/src/parser.ts

@@ -0,0 +1,138 @@
+// src/parser.ts
+import type { SearchType } from "./index.js";
+
+export interface BaseMeta {
+  _idx: number;
+  title?: string;
+  url?: string;
+}
+export interface WebMeta extends BaseMeta { summary?: string; favicon?: string; }
+export interface ImageMeta extends BaseMeta { thumbnail?: string; domain?: string; }
+export interface VideoMeta extends BaseMeta { thumbnail?: string; duration?: string; publishedDate?: string; }
+export interface NewsMeta extends BaseMeta { summary?: string; favicon?: string; publishedDate?: string; }
+export type ResultMeta = WebMeta | ImageMeta | VideoMeta | NewsMeta | BaseMeta;
+export type ResultDetail = ResultMeta & { [key: string]: unknown };
+export interface ParsedResponse { meta: ResultMeta[]; raw: unknown; }
+
+const META_FIELDS_BY_TYPE: Record<string, readonly string[]> = {
+  web:   ["title", "url", "summary", "favicon"],
+  news:  ["title", "url", "summary", "favicon", "publishedDate"],
+  image: ["title", "url", "thumbnail", "domain"],
+  video: ["title", "url", "thumbnail", "duration", "publishedDate"],
+};
+
+const HEAVY_FIELDS = new Set<string>(["summary"]);
+
+const FIELD_ALIASES: Record<string, readonly string[]> = {
+  url:           ["url", "href", "link"],
+  thumbnail:     ["thumbnail", "image", "img", "thumb"],
+  favicon:       ["favicon", "icon"],
+  domain:        ["domain", "source", "siteName"],
+  summary:       ["summary", "description", "snippet", "desc", "content"],
+  publishedDate: ["publishedDate", "date", "published", "publishedAt"],
+  duration:      ["duration", "length"],
+};
+
+export function extractMeta(
+  data: unknown,
+  type: SearchType = "web",
+  lowMemory = false
+): ResultMeta[] {
+  const fields = _fieldsForType(type, lowMemory);
+  const arr = _toArray(data);
+  const result: ResultMeta[] = new Array(arr.length);
+  for (let i = 0; i < arr.length; i++) {
+    const obj = _safeObj(arr[i]);
+    const meta: Record<string, unknown> = { _idx: i };
+    for (const f of fields) {
+      const v = _resolve(obj, f);
+      if (v !== undefined) meta[f] = v;
+    }
+    // _idx は必ず存在するので unknown 経由のキャストで型安全
+    result[i] = meta as unknown as ResultMeta;
+  }
+  return result;
+}
+
+export function extractDetail(data: unknown, idx: number): ResultDetail | null {
+  const arr = _toArray(data);
+  if (idx < 0 || idx >= arr.length) return null;
+  const obj = _safeObj(arr[idx]);
+  return {
+    _idx: idx,
+    title:         _resolve(obj, "title"),
+    url:           _resolve(obj, "url"),
+    thumbnail:     _resolve(obj, "thumbnail"),
+    favicon:       _resolve(obj, "favicon"),
+    domain:        _resolve(obj, "domain"),
+    summary:       _resolve(obj, "summary"),
+    duration:      _resolve(obj, "duration"),
+    publishedDate: _resolve(obj, "publishedDate"),
+    ...obj,
+  };
+}
+
+export function chunkToMeta(
+  chunk: unknown,
+  type: SearchType = "web",
+  lowMemory = false
+): ResultMeta | null {
+  if (!chunk) return null;
+  const fields = _fieldsForType(type, lowMemory);
+  const tryObj = _safeObj(chunk);
+  if ("title" in tryObj || "url" in tryObj) return _buildMeta(tryObj, fields);
+  const arr = _toArray(chunk);
+  if (arr.length > 0) return chunkToMeta(arr[0], type, lowMemory);
+  return null;
+}
+
+function _fieldsForType(type: SearchType, lowMemory: boolean): readonly string[] {
+  const base = META_FIELDS_BY_TYPE[type] ?? ["title", "url"];
+  if (!lowMemory) return base;
+  return base.filter((f) => !HEAVY_FIELDS.has(f));
+}
+
+function _buildMeta(obj: Record<string, unknown>, fields: readonly string[]): ResultMeta {
+  const meta: Record<string, unknown> = {
+    _idx: typeof obj._idx === "number" ? obj._idx : 0,
+  };
+  for (const f of fields) {
+    const v = _resolve(obj, f);
+    if (v !== undefined) meta[f] = v;
+  }
+  return meta as unknown as ResultMeta;
+}
+
+function _resolve(obj: Record<string, unknown>, field: string): string | undefined {
+  const aliases = FIELD_ALIASES[field];
+  if (aliases) {
+    for (const key of aliases) {
+      const v = _str(obj[key]);
+      if (v !== undefined) return v;
+    }
+    return undefined;
+  }
+  return _str(obj[field]);
+}
+
+function _safeObj(v: unknown): Record<string, unknown> {
+  return v && typeof v === "object" ? (v as Record<string, unknown>) : {};
+}
+
+function _str(v: unknown): string | undefined {
+  if (typeof v === "string") { const s = v.trim(); return s.length > 0 ? s : undefined; }
+  if (typeof v === "number") return String(v);
+  return undefined;
+}
+
+function _toArray(data: unknown): unknown[] {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object") {
+    const obj = data as Record<string, unknown>;
+    for (const key of ["results", "items", "data", "hits", "entries", "docs"]) {
+      const v = obj[key];
+      if (Array.isArray(v)) return v;
+    }
+  }
+  return [];
+}

package/src/request/queue.ts

@@ -0,0 +1,38 @@
+// src/request/queue.ts
+import { getConfig } from "../config.js";
+import { getIsLowMemory } from "../memory.js";
+
+export type PriorityValue = 0 | 1 | 2;
+
+export const Priority = {
+  LOW: 0 as PriorityValue,
+  NORMAL: 1 as PriorityValue,
+  HIGH: 2 as PriorityValue,
+} as const;
+
+type Task = () => Promise<void>;
+
+const _queues: [Task[], Task[], Task[]] = [[], [], []];
+let _running = 0;
+
+export function enqueue(task: Task, priority: PriorityValue = Priority.NORMAL): void {
+  _queues[priority].push(task);
+  _drain();
+}
+
+export function clearQueues(): void {
+  _queues[0].length = 0;
+  _queues[1].length = 0;
+  _queues[2].length = 0;
+}
+
+function _drain(): void {
+  const cfg = getConfig();
+  const max = getIsLowMemory() ? cfg.MAX_CONCURRENT_LOW_MEMORY : cfg.MAX_CONCURRENT_REQUESTS;
+  while (_running < max) {
+    const task = _queues[2].shift() ?? _queues[1].shift() ?? _queues[0].shift();
+    if (!task) break;
+    _running++;
+    task().finally(() => { _running--; _drain(); });
+  }
+}

package/src/request/retry.ts

@@ -0,0 +1,162 @@
+// src/request/retry.ts
+import { getConfig } from "../config.js";
+
+export interface FetchResult {
+  ok: boolean;
+  data?: unknown;
+  error?: string;
+  status?: number;
+  cached?: boolean;
+  stale?: boolean;
+  persistent?: boolean;
+  streamed?: boolean;
+}
+
+const controllers = new Map<string, AbortController>();
+
+export function cancel(key: string): void {
+  controllers.get(key)?.abort();
+  controllers.delete(key);
+}
+
+export function cancelAll(): void {
+  for (const ctrl of controllers.values()) ctrl.abort();
+  controllers.clear();
+}
+
+export async function fetchWithRetry(
+  url: string,
+  opts: RequestInit,
+  key: string,
+  onChunk?: (chunk: unknown) => void
+): Promise<FetchResult> {
+  const cfg = getConfig();
+  const canAbort = typeof AbortController !== "undefined";
+  const canStream = typeof ReadableStream !== "undefined" && !!onChunk;
+
+  for (let attempt = 0; attempt <= cfg.RETRIES; attempt++) {
+    controllers.get(key)?.abort();
+    const ctrl = canAbort ? new AbortController() : null;
+    if (ctrl) controllers.set(key, ctrl);
+
+    const externalSignal = opts.signal as AbortSignal | undefined;
+    let mergedSignal: AbortSignal | undefined;
+
+    if (ctrl && externalSignal) {
+      if (typeof AbortSignal.any === "function") {
+        mergedSignal = AbortSignal.any([ctrl.signal, externalSignal]);
+      } else {
+        const bridge = (): void => ctrl.abort();
+        externalSignal.addEventListener("abort", bridge, { once: true });
+        mergedSignal = ctrl.signal;
+      }
+    } else {
+      mergedSignal = ctrl?.signal ?? externalSignal ?? undefined;
+    }
+
+    const fetchOpts: RequestInit = mergedSignal ? { ...opts, signal: mergedSignal } : opts;
+    const tid = ctrl ? setTimeout(() => ctrl.abort(), cfg.TIMEOUT) : undefined;
+
+    try {
+      const res = await fetch(url, fetchOpts);
+      clearTimeout(tid);
+      controllers.delete(key);
+
+      if (!res.ok) {
+        return {
+          ok: false,
+          error: res.status >= 500 ? "server_error" : "client_error",
+          status: res.status,
+        };
+      }
+
+      if (canStream && res.body) return await _readStream(res.body, ctrl, onChunk!, cfg);
+      return { ok: true, data: await res.json() };
+
+    } catch (err) {
+      clearTimeout(tid);
+      controllers.delete(key);
+
+      if (err instanceof Error) {
+        if (err.name === "AbortError" || err.message?.includes("aborted")) {
+          return { ok: false, error: "cancelled" };
+        }
+        if (err instanceof TypeError) {
+          if (attempt === cfg.RETRIES) return { ok: false, error: "network_error" };
+          await _sleep(cfg.RETRY_BACKOFF_BASE * 2 ** attempt);
+          continue;
+        }
+      }
+      return { ok: false, error: "unknown_error" };
+    }
+  }
+
+  return { ok: false, error: "max_retries_exceeded" };
+}
+
+const _sleep = (ms: number): Promise<void> => new Promise<void>((r) => setTimeout(r, ms));
+
+async function _readStream(
+  body: ReadableStream<Uint8Array>,
+  ctrl: AbortController | null,
+  onChunk: (chunk: unknown) => void,
+  cfg: ReturnType<typeof getConfig>
+): Promise<FetchResult> {
+  const reader = body.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  let braces = 0;
+  let inStr = false;
+  let esc = false;
+  let aborted = false;
+  const chunks: unknown[] = [];
+
+  const onAbort = (): void => { aborted = true; reader.cancel().catch(() => {}); };
+  ctrl?.signal.addEventListener("abort", onAbort, { once: true });
+
+  try {
+    outer: while (!aborted) {
+      let readResult: ReadableStreamReadResult<Uint8Array>;
+      try { readResult = await reader.read(); }
+      catch { break outer; }
+      if (readResult.done) break;
+      buf += dec.decode(readResult.value, { stream: true });
+      if (buf.length > cfg.STREAMING_BUFFER_SIZE) _flush();
+    }
+    if (!aborted) _flush();
+  } finally {
+    ctrl?.signal.removeEventListener("abort", onAbort);
+    try { reader.releaseLock(); } catch { /* already released */ }
+    buf = "";
+  }
+
+  return {
+    ok: !aborted,
+    ...(aborted ? { error: "cancelled" } : {}),
+    data: chunks.length === 1 ? chunks[0] : chunks,
+    streamed: true,
+  };
+
+  function _flush(): void {
+    let start = 0;
+    for (let i = 0; i < buf.length; i++) {
+      const c = buf[i];
+      if (esc)        { esc = false; continue; }
+      if (c === "\\") { esc = true;  continue; }
+      if (c === '"')  { inStr = !inStr; continue; }
+      if (inStr)      continue;
+      if (c === "{")  { if (!braces) start = i; braces++; }
+      else if (c === "}") {
+        if (!--braces) {
+          try {
+            const obj: unknown = JSON.parse(buf.slice(start, i + 1));
+            chunks.push(obj);
+            onChunk(obj);
+          } catch { /* malformed JSON */ }
+          buf = buf.slice(i + 1);
+          i = -1;
+        }
+      }
+    }
+  }
+}

package/src/suggest.ts

@@ -0,0 +1,174 @@
+// src/suggest.ts
+import { getConfig } from "./config.js";
+import { getIsLowMemory } from "./memory.js";
+import { fetchWithRetry, type FetchResult } from "./request/retry.js";
+import { enqueue, Priority } from "./request/queue.js";
+import { debounce } from "./utils.js";
+
+export interface SuggestItem { title: string; }
+
+export interface SuggestResult {
+  ok: boolean;
+  query: string;
+  items: SuggestItem[];
+  cached?: boolean;
+  error?: string;
+}
+
+interface SuggestCacheEntry { items: SuggestItem[]; time: number; }
+
+const _cache = new Map<string, SuggestCacheEntry>();
+const SUGGEST_CACHE_MAX = 50;
+
+function _cacheKey(q: string): string { return q.trim().toLowerCase(); }
+
+function _cacheGet(key: string): SuggestCacheEntry | null {
+  const entry = _cache.get(key);
+  if (!entry) return null;
+  if (Date.now() - entry.time > getConfig().SUGGEST_TTL) { _cache.delete(key); return null; }
+  _cache.delete(key);
+  _cache.set(key, entry);
+  return entry;
+}
+
+function _cacheSet(key: string, items: SuggestItem[]): void {
+  if (_cache.has(key)) _cache.delete(key);
+  while (_cache.size >= SUGGEST_CACHE_MAX) {
+    const first = _cache.keys().next().value;
+    if (first !== undefined) _cache.delete(first as string);
+    else break;
+  }
+  _cache.set(key, { items, time: Date.now() });
+}
+
+function _cacheFindPrefix(q: string): SuggestCacheEntry | null {
+  const key = _cacheKey(q);
+  const exact = _cacheGet(key);
+  if (exact) return exact;
+  const now = Date.now();
+  const ttl = getConfig().SUGGEST_TTL;
+  for (const [k, entry] of _cache) {
+    if (now - entry.time > ttl) { _cache.delete(k); continue; }
+    if (key.startsWith(k)) {
+      _cache.delete(k);
+      _cache.set(k, entry);
+      const filtered = entry.items.filter((item) => item.title.toLowerCase().includes(key));
+      if (filtered.length > 0) return { items: filtered, time: entry.time };
+    }
+  }
+  return null;
+}
+
+export function clearSuggestCache(): void { _cache.clear(); }
+
+const _inFlight = new Map<string, Promise<SuggestResult>>();
+
+const _fetchOpts: RequestInit = Object.freeze({
+  method: "GET",
+  headers: Object.freeze({ Accept: "application/json" }),
+});
+
+async function _fetchSuggest(q: string): Promise<SuggestResult> {
+  const key = _cacheKey(q);
+  const cached = _cacheFindPrefix(q);
+  if (cached) return { ok: true, query: q, items: cached.items, cached: true };
+
+  const existing = _inFlight.get(key);
+  if (existing) return existing;
+
+  const cfg = getConfig();
+  const url = new URL(cfg.API_BASE + "/search");
+  url.searchParams.set("q", q.trim());
+  url.searchParams.set("type", "suggest");
+
+  const promise = new Promise<SuggestResult>((resolve) => {
+    enqueue(async () => {
+      try {
+        const result: FetchResult = await fetchWithRetry(
+          url.toString(), _fetchOpts, "suggest\x00" + key
+        );
+        if (!result.ok) { resolve({ ok: false, query: q, items: [], error: result.error }); return; }
+        const items = _parse(result.data);
+        _cacheSet(key, items);
+        resolve({ ok: true, query: q, items });
+      } catch {
+        resolve({ ok: false, query: q, items: [], error: "unknown_error" });
+      } finally {
+        _inFlight.delete(key);
+      }
+    }, Priority.HIGH);
+  });
+
+  _inFlight.set(key, promise);
+  return promise;
+}
+
+function _parse(data: unknown): SuggestItem[] {
+  return _toArray(data).reduce<SuggestItem[]>((acc, item) => {
+    const title = _title(item);
+    if (title) acc.push({ title });
+    return acc;
+  }, []);
+}
+
+function _title(item: unknown): string | undefined {
+  if (typeof item === "string" && item.length > 0) return item;
+  if (item && typeof item === "object") {
+    const obj = item as Record<string, unknown>;
+    const v = obj.title ?? obj.text ?? obj.value ?? obj.query;
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return undefined;
+}
+
+function _toArray(data: unknown): unknown[] {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object") {
+    const obj = data as Record<string, unknown>;
+    for (const key of ["results", "items", "suggestions", "data"]) {
+      if (Array.isArray(obj[key])) return obj[key] as unknown[];
+    }
+  }
+  return [];
+}
+
+export function getSuggest(q: string): Promise<SuggestResult> {
+  if (!q.trim()) return Promise.resolve({ ok: true, query: q, items: [] });
+  if (getIsLowMemory()) {
+    const half = Math.ceil(SUGGEST_CACHE_MAX / 2);
+    while (_cache.size > half) {
+      const first = _cache.keys().next().value;
+      if (first !== undefined) _cache.delete(first as string);
+      else break;
+    }
+  }
+  return _fetchSuggest(q);
+}
+
+export function getSuggestDebounced(
+  q: string,
+  callback: (result: SuggestResult) => void,
+  wait?: number
+): void {
+  _debouncedInner(q, callback, wait ?? getConfig().SUGGEST_DEBOUNCE_MS);
+}
+
+const _debouncedFns = new Map<number, (q: string, cb: (r: SuggestResult) => void) => void>();
+
+function _debouncedInner(
+  q: string,
+  callback: (result: SuggestResult) => void,
+  wait: number
+): void {
+  if (!_debouncedFns.has(wait)) {
+    // debounce に渡すラッパーを明示的に unknown[] 型にする
+    const fn = (innerQ: unknown, cb: unknown): void => {
+      getSuggest(innerQ as string)
+        .then(cb as (r: SuggestResult) => void)
+        .catch(() => (cb as (r: SuggestResult) => void)({ ok: false, query: innerQ as string, items: [], error: "unknown" }));
+    };
+    _debouncedFns.set(wait, debounce(fn, { delay: wait, usePromise: false }) as unknown as
+      (q: string, cb: (r: SuggestResult) => void) => void);
+  }
+  _debouncedFns.get(wait)!(q, callback);
+}

package/src/utils.ts

@@ -0,0 +1,101 @@
+// src/utils.ts
+import { getIsLowMemory } from "./memory.js";
+
+// AnyFunction は内部型のみ。外部引数は T extends (...args: never[]) => unknown で表現
+type AnyFunction = (...args: never[]) => unknown;
+
+interface DebounceOptions {
+  delay?: number;
+  leading?: boolean;
+  trailing?: boolean;
+  usePromise?: boolean;
+}
+
+export function debounce<T extends AnyFunction>(
+  fn: T,
+  options: DebounceOptions | number = {}
+) {
+  const opts: DebounceOptions =
+    typeof options === "number" ? { delay: options } : options;
+
+  const {
+    delay = 300,
+    leading = false,
+    trailing = true,
+    usePromise = true,
+  } = opts;
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let lastArgs: Parameters<T> | undefined;
+  let pending:
+    | { resolve: (v: ReturnType<T>) => void; reject: (e: unknown) => void }
+    | undefined;
+
+  const getDelay = (): number => (getIsLowMemory() ? delay * 2 : delay);
+
+  const execute = async (): Promise<ReturnType<T>> => {
+    if (!lastArgs) return undefined as ReturnType<T>;
+    try {
+      const result = await (fn as (...a: Parameters<T>) => ReturnType<T>)(...lastArgs);
+      pending?.resolve(result);
+      return result;
+    } catch (e) {
+      pending?.reject(e);
+      throw e;
+    } finally {
+      pending = undefined;
+    }
+  };
+
+  const debounced = (...args: Parameters<T>): Promise<ReturnType<T>> | void => {
+    lastArgs = args;
+    const shouldCallNow = leading && !timer;
+    if (timer) clearTimeout(timer);
+
+    if (shouldCallNow) {
+      if (usePromise) {
+        return Promise.resolve(
+          (fn as (...a: Parameters<T>) => ReturnType<T>)(...args)
+        );
+      }
+      (fn as (...a: Parameters<T>) => unknown)(...args);
+      return;
+    }
+
+    if (!trailing) return;
+
+    if (usePromise) {
+      return new Promise<ReturnType<T>>((resolve, reject) => {
+        pending?.reject(new Error("debounced_cancelled"));
+        pending = { resolve, reject };
+        timer = setTimeout(() => {
+          timer = undefined;
+          void execute();
+        }, getDelay());
+      });
+    }
+
+    timer = setTimeout(() => {
+      timer = undefined;
+      void (fn as (...a: Parameters<T>) => unknown)(...(lastArgs as Parameters<T>));
+    }, getDelay());
+  };
+
+  debounced.cancel = (): void => {
+    if (timer) { clearTimeout(timer); timer = undefined; }
+    pending?.reject(new Error("debounced_cancelled"));
+    pending = undefined;
+  };
+
+  debounced.flush = (): Promise<ReturnType<T>> | undefined => {
+    if (!timer) return;
+    clearTimeout(timer);
+    timer = undefined;
+    return execute();
+  };
+
+  return debounced as typeof debounced & {
+    cancel: () => void;
+    flush: () => Promise<ReturnType<T>> | undefined;
+  };
+}