dropcap 1.1.0 → 1.4.0

package/dist/utils/utils.js

@@ -1,202 +1,35 @@
-// src/utils/utils-color-hash.ts
-function colorHash(str) {
-  let hash = 5381;
-  for (let i = 0; i < str.length; i++) {
-    hash = hash * 33 ^ str.charCodeAt(i);
-  }
-  hash >>>= 0;
-  const hue = Math.floor(hash * 0.618033988749895 % 1 * 360);
-  const sat = 70;
-  let light = 50;
-  for (let i = 0; i < 20; i++) {
-    const rgb = hsl2rgb(hue, sat, light);
-    const l = lum(rgb);
-    const cW = contrast(1, l);
-    const cB = contrast(0, l);
-    if (cW >= 4.5 && cB >= 4.5) break;
-    light += cW < cB ? -5 : 5;
-  }
-  const hex = hsl2rgb(hue, sat, light).map((v) => v.toString(16).padStart(2, "0")).join("");
-  return `#${hex}`;
-}
-function hsl2rgb(hh, ss, ll) {
-  ss /= 100;
-  ll /= 100;
-  const k = (n) => (n + hh / 30) % 12;
-  const a = ss * Math.min(ll, 1 - ll);
-  const f = (n) => ll - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
-  return [f(0), f(8), f(4)].map((v) => Math.round(v * 255));
-}
-function lum([r, g, b]) {
-  const c = (x) => {
-    x /= 255;
-    return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
-  };
-  return 0.2126 * c(r) + 0.7152 * c(g) + 0.0722 * c(b);
-}
-function contrast(l1, l2) {
-  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
-}
-
-// src/utils/utils-create-log.ts
-function createLog(name) {
-  const color = colorHash(name);
-  const log = print.bind(null, "log", name, color);
-  log.warn = print.bind(null, "warn", name, color);
-  log.error = print.bind(null, "error", name, color);
-  return log;
-}
-function print(type, name, color, ...args) {
-  console[type](`%c[${name}]`, `color: ${color}`, ...args);
-}
-
-// src/utils/utils-ensure-array.ts
-function ensureArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-
-// src/utils/utils-is.ts
-var is = {
-  null: (v) => v === null,
-  undefined: (v) => v === void 0,
-  boolean: (v) => typeof v === "boolean",
-  number: (v) => typeof v === "number",
-  string: (v) => typeof v === "string",
-  symbol: (v) => typeof v === "symbol",
-  function: (v) => typeof v === "function",
-  object: (v) => Object.prototype.toString.call(v) === "[object Object]",
-  array: (v) => Array.isArray(v),
-  set: (v) => v instanceof Set,
-  map: (v) => v instanceof Map,
-  blob: (v) => v instanceof Blob,
-  date: (v) => v instanceof Date,
-  error: (v) => v instanceof Error,
-  regex: (v) => v instanceof RegExp,
-  promise: (v) => v instanceof Promise,
-  uint8Array: (v) => v instanceof Uint8Array,
-  uint16Array: (v) => v instanceof Uint16Array,
-  uint32Array: (v) => v instanceof Uint32Array,
-  nan: (v) => Number.isNaN(v),
-  numeric: (v) => !is.nan(Number(v)),
-  integer: (v) => Number.isInteger(v),
-  absent: (v) => v === null || v === void 0,
-  present: (v) => !is.absent(v),
-  primitive: (v) => v !== Object(v),
-  collection: (v) => is.array(v) || is.object(v),
-  compound: (v) => v !== null && typeof v === "object"
-};
-
-// src/utils/utils-safe.ts
-async function safe(effect) {
-  try {
-    const result = is.function(effect) ? await effect() : await effect;
-    return [result, null];
-  } catch (e) {
-    const error = e instanceof Error ? e : new Error(String(e));
-    return [null, error];
-  }
-}
-function safeSync(effect) {
-  try {
-    const result = effect();
-    return [result, null];
-  } catch (e) {
-    const error = e instanceof Error ? e : new Error(String(e));
-    return [null, error];
-  }
-}
-
-// src/utils/utils-queue.ts
-var Queue = class {
-  name;
-  tasks = [];
-  running = false;
-  constructor(name = null) {
-    this.name = name;
-  }
-  async add(fn) {
-    const task = { fn, result$: Promise.withResolvers() };
-    this.tasks.push(task);
-    this.start();
-    return await task.result$.promise;
-  }
-  wrap(fn, thisValue = null) {
-    return (async (...args) => {
-      return await this.add(() => fn.call(thisValue, ...args));
-    });
-  }
-  async wait() {
-    const lastTask = this.tasks.at(-1);
-    if (lastTask) await safe(lastTask.result$.promise);
-  }
-  isEmpty() {
-    return this.tasks.length === 0;
-  }
-  async start() {
-    if (this.running) return;
-    if (this.isEmpty()) return;
-    this.running = true;
-    while (this.tasks.length > 0) {
-      const task = this.tasks[0];
-      if (!task) break;
-      const [result, error] = await safe(task.fn);
-      this.tasks.shift();
-      if (error) {
-        task.result$.reject(error);
-      } else {
-        task.result$.resolve(result);
-      }
-    }
-    this.running = false;
-  }
-};
-
-// src/utils/utils-unique.ts
-function unique(items, keyFn) {
-  if (!keyFn) return [...new Set(items)];
-  const seen = /* @__PURE__ */ new Set();
-  return items.filter((item) => {
-    const key = keyFn(item);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-// src/utils/utils-unit.ts
-var Unit = class {
-  $;
-  log = createLog(this.constructor.name);
-  #parent = null;
-  constructor(parent) {
-    this.$ = parent?.$ ?? this;
-    this.#parent = parent ?? null;
-  }
-  closest(Ancestor) {
-    let cursor = this.#parent;
-    while (cursor) {
-      if (cursor instanceof Ancestor) return cursor;
-      cursor = cursor.#parent;
-    }
-    return null;
-  }
-  never(message) {
-    const details = message ? `: ${message}` : "";
-    const error = new Error(`[${this.constructor.name}] This should never happen${details}`);
-    Error.captureStackTrace(error, this.never);
-    return error;
-  }
-  Error(message) {
-    const error = new Error(`[${this.constructor.name}] ${message}`);
-    Error.captureStackTrace(error, this.Error);
-    return error;
-  }
-};
-
-// src/utils/utils-wait.ts
-async function wait(ms) {
-  await new Promise((r) => setTimeout(r, ms));
-}
+import "../chunk-SDOWUYJK.js";
+import {
+  unique
+} from "../chunk-OURJLKNI.js";
+import {
+  Unit
+} from "../chunk-IEKJYSB2.js";
+import {
+  wait
+} from "../chunk-RXAMNVZW.js";
+import {
+  createLog
+} from "../chunk-IL3H2YKT.js";
+import {
+  colorHash
+} from "../chunk-NIQOLOOJ.js";
+import {
+  ensureArray
+} from "../chunk-6X6FFIZN.js";
+import {
+  link
+} from "../chunk-WBZCJMFI.js";
+import {
+  Queue
+} from "../chunk-5N6O5FSZ.js";
+import {
+  safe,
+  safeSync
+} from "../chunk-YPFVC6GE.js";
+import {
+  is
+} from "../chunk-IQMQQI6W.js";
 export {
   Queue,
   Unit,
@@ -204,8 +37,10 @@ export {
   createLog,
   ensureArray,
   is,
+  link,
   safe,
   safeSync,
   unique,
   wait
 };
+//# sourceMappingURL=utils.js.map

package/dist/utils/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dropcap",
-  "version": "1.1.0",
+  "version": "1.4.0",
   "type": "module",
   "license": "MIT",
   "author": "imkost",
@@ -12,13 +12,11 @@
     "release": "sh -c 'npm version ${1:-minor} && npm run build && npm publish' --"
   },
   "exports": {
+    "./idb": "./dist/idb/idb.js",
     "./utils": "./dist/utils/utils.js",
-    "./types": "./dist/types/types.js",
-    "./utils/ts": "./src/utils/utils.ts",
-    "./types/ts": "./src/types/types.ts"
+    "./types": "./dist/types/types.js"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ]
 }

package/src/types/types.ts

@@ -1,5 +0,0 @@
-export type Obj = Record<PropertyKey, unknown>
-export type Arr = unknown[]
-export type Cls<T = any> = new (...args: any[]) => T
-export type Fn<T = any> = (...args: any[]) => T
-export type AsyncFn<T = any> = (...args: any[]) => Promise<T>

package/src/utils/utils-color-hash.ts

@@ -1,55 +0,0 @@
-export type Rgb = [number, number, number]
-
-export function colorHash(str: string) {
-  // Calculate hash (djb2 xor) as 32‑bit unsigned
-  let hash = 5381
-  for (let i = 0; i < str.length; i++) {
-    hash = (hash * 33) ^ str.charCodeAt(i)
-  }
-  hash >>>= 0
-
-  // Calculate hue. Golden‑ratio scramble gives maximum spread for 'near' strings.
-  const hue = Math.floor(((hash * 0.618033988749895) % 1) * 360)
-
-  // Start with vivid mid‑tone
-  const sat = 70
-  let light = 50
-
-  // Adjust lightness until it reads on both white and black backgrounds.
-  for (let i = 0; i < 20; i++) {
-    const rgb = hsl2rgb(hue, sat, light)
-    const l = lum(rgb)
-    const cW = contrast(1, l) // Versus white
-    const cB = contrast(0, l) // Versus black
-    if (cW >= 4.5 && cB >= 4.5) break // Good on both
-    light += cW < cB ? -5 : 5 // Move toward darker or lighter
-  }
-
-  // Convert to hex
-  const hex = hsl2rgb(hue, sat, light)
-    .map(v => v.toString(16).padStart(2, '0'))
-    .join('')
-
-  return `#${hex}`
-}
-
-function hsl2rgb(hh: number, ss: number, ll: number): Rgb {
-  ss /= 100
-  ll /= 100
-  const k = (n: number) => (n + hh / 30) % 12
-  const a = ss * Math.min(ll, 1 - ll)
-  const f = (n: number) => ll - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)))
-  return [f(0), f(8), f(4)].map(v => Math.round(v * 255)) as Rgb
-}
-
-function lum([r, g, b]: Rgb) {
-  const c = (x: number) => {
-    x /= 255
-    return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4
-  }
-  return 0.2126 * c(r) + 0.7152 * c(g) + 0.0722 * c(b)
-}
-
-function contrast(l1: number, l2: number) {
-  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05)
-}

package/src/utils/utils-create-log.ts

@@ -1,16 +0,0 @@
-import type { Fn } from '../types/types.js'
-import { colorHash } from './utils-color-hash.js'
-
-export type Log = Fn<void> & { warn: Fn<void>; error: Fn<void> }
-
-export function createLog(name: string) {
-  const color = colorHash(name)
-  const log = print.bind(null, 'log', name, color) as Log
-  log.warn = print.bind(null, 'warn', name, color) as Log['warn']
-  log.error = print.bind(null, 'error', name, color) as Log['error']
-  return log
-}
-
-function print(type: 'log' | 'warn' | 'error', name: string, color: string, ...args: unknown[]) {
-  console[type](`%c[${name}]`, `color: ${color}`, ...args)
-}

package/src/utils/utils-ensure-array.ts

@@ -1,3 +0,0 @@
-export function ensureArray<T>(value: T | T[]): T[] {
-  return Array.isArray(value) ? value : [value]
-}

package/src/utils/utils-is.ts

@@ -1,32 +0,0 @@
-import type { Fn, Obj, Arr } from '../types/types.js'
-
-export const is = {
-  null: (v: unknown) => v === null,
-  undefined: (v: unknown) => v === undefined,
-  boolean: (v: unknown) => typeof v === 'boolean',
-  number: (v: unknown) => typeof v === 'number',
-  string: (v: unknown) => typeof v === 'string',
-  symbol: (v: unknown) => typeof v === 'symbol',
-  function: (v: unknown): v is Fn => typeof v === 'function',
-  object: (v: unknown): v is Obj => Object.prototype.toString.call(v) === '[object Object]',
-  array: (v: unknown): v is Arr => Array.isArray(v),
-  set: (v: unknown) => v instanceof Set,
-  map: (v: unknown) => v instanceof Map,
-  blob: (v: unknown) => v instanceof Blob,
-  date: (v: unknown) => v instanceof Date,
-  error: (v: unknown) => v instanceof Error,
-  regex: (v: unknown) => v instanceof RegExp,
-  promise: (v: unknown) => v instanceof Promise,
-  uint8Array: (v: unknown) => v instanceof Uint8Array,
-  uint16Array: (v: unknown) => v instanceof Uint16Array,
-  uint32Array: (v: unknown) => v instanceof Uint32Array,
-
-  nan: (v: unknown) => Number.isNaN(v),
-  numeric: (v: unknown) => !is.nan(Number(v)),
-  integer: (v: unknown): v is number => Number.isInteger(v),
-  absent: (v: unknown) => v === null || v === undefined,
-  present: <T>(v: T): v is NonNullable<T> => !is.absent(v),
-  primitive: (v: unknown) => v !== Object(v),
-  collection: (v: unknown) => is.array(v) || is.object(v),
-  compound: (v: unknown) => v !== null && typeof v === 'object',
-}

package/src/utils/utils-queue.ts

@@ -1,58 +0,0 @@
-import { safe } from './utils-safe.js'
-import type { AsyncFn } from '../types/types.js'
-
-type TaskFn<T> = () => Promise<T>
-type Task<T = any> = { fn: TaskFn<T>; result$: PromiseWithResolvers<T> }
-
-export class Queue {
-  name: string | null
-  tasks: Task[] = []
-  private running = false
-
-  constructor(name: string | null = null) {
-    this.name = name
-  }
-
-  async add<T>(fn: TaskFn<T>): Promise<T> {
-    const task: Task<T> = { fn, result$: Promise.withResolvers<T>() }
-    this.tasks.push(task)
-    this.start()
-    return await task.result$.promise
-  }
-
-  wrap<T extends AsyncFn>(fn: T, thisValue: unknown = null) {
-    return (async (...args: Parameters<T>) => {
-      return await this.add(() => fn.call(thisValue, ...args))
-    }) as T
-  }
-
-  async wait() {
-    const lastTask = this.tasks.at(-1)
-    if (lastTask) await safe(lastTask.result$.promise)
-  }
-
-  isEmpty() {
-    return this.tasks.length === 0
-  }
-
-  private async start() {
-    if (this.running) return
-    if (this.isEmpty()) return
-
-    this.running = true
-
-    while (this.tasks.length > 0) {
-      const task = this.tasks[0]
-      if (!task) break
-      const [result, error] = await safe(task.fn)
-      this.tasks.shift()
-      if (error) {
-        task.result$.reject(error)
-      } else {
-        task.result$.resolve(result)
-      }
-    }
-
-    this.running = false
-  }
-}

package/src/utils/utils-safe.ts

@@ -1,23 +0,0 @@
-import { is } from './utils-is.js'
-
-export async function safe<T>(
-  effect: (() => T | Promise<T>) | Promise<T>,
-): Promise<[T, null] | [null, Error]> {
-  try {
-    const result = is.function(effect) ? await effect() : await effect
-    return [result, null]
-  } catch (e) {
-    const error = e instanceof Error ? e : new Error(String(e))
-    return [null, error]
-  }
-}
-
-export function safeSync<T>(effect: () => T): [T, null] | [null, Error] {
-  try {
-    const result = effect()
-    return [result, null]
-  } catch (e) {
-    const error = e instanceof Error ? e : new Error(String(e))
-    return [null, error]
-  }
-}

package/src/utils/utils-unique.ts

@@ -1,11 +0,0 @@
-export function unique<T = unknown>(items: T[], keyFn?: (item: T) => unknown) {
-  if (!keyFn) return [...new Set(items)]
-
-  const seen = new Set()
-  return items.filter(item => {
-    const key = keyFn(item)
-    if (seen.has(key)) return false
-    seen.add(key)
-    return true
-  })
-}

package/src/utils/utils-unit.ts

@@ -1,35 +0,0 @@
-import type { Cls } from '../types/types.js'
-import { createLog } from './utils-create-log.js'
-
-export class Unit<TRoot = unknown> {
-  $: TRoot
-  log = createLog(this.constructor.name)
-  #parent: Unit<TRoot> | null = null
-
-  constructor(parent?: Unit<TRoot> | null) {
-    this.$ = (parent?.$ ?? this) as TRoot
-    this.#parent = parent ?? null
-  }
-
-  closest<T extends Unit<TRoot>>(Ancestor: Cls<T>): T | null {
-    let cursor = this.#parent
-    while (cursor) {
-      if (cursor instanceof Ancestor) return cursor as T
-      cursor = cursor.#parent
-    }
-    return null
-  }
-
-  never(message?: string) {
-    const details = message ? `: ${message}` : ''
-    const error = new Error(`[${this.constructor.name}] This should never happen${details}`)
-    Error.captureStackTrace(error, this.never)
-    return error
-  }
-
-  Error(message?: string) {
-    const error = new Error(`[${this.constructor.name}] ${message}`)
-    Error.captureStackTrace(error, this.Error)
-    return error
-  }
-}

package/src/utils/utils-wait.ts

@@ -1,3 +0,0 @@
-export async function wait(ms: number) {
-  await new Promise(r => setTimeout(r, ms))
-}

package/src/utils/utils.ts

@@ -1,13 +0,0 @@
-import { colorHash } from './utils-color-hash.js'
-import { createLog, type Log } from './utils-create-log.js'
-import { ensureArray } from './utils-ensure-array.js'
-import { is } from './utils-is.js'
-import { Queue } from './utils-queue.js'
-import { safe, safeSync } from './utils-safe.js'
-import { unique } from './utils-unique.js'
-import { Unit } from './utils-unit.js'
-import { wait } from './utils-wait.js'
-
-export type { Log }
-
-export { colorHash, createLog, ensureArray, is, Queue, safe, safeSync, unique, Unit, wait }