@qkitt/queue 0.1.0 → 0.1.1

package/dist/chunk-SMQYICXZ.js

@@ -0,0 +1,203 @@
+// src/persist/memory.ts
+var createMemorySnapshotStore = (initial = []) => {
+  const data = [...initial];
+  return {
+    get data() {
+      return data;
+    },
+    load: () => data.slice(),
+    save: (items) => {
+      data.length = 0;
+      data.push(...items);
+    }
+  };
+};
+var createMemoryRowStore = (initial = []) => {
+  const rows = initial.map((row) => ({
+    id: row.id,
+    item: row.item
+  }));
+  return {
+    get rows() {
+      return rows;
+    },
+    loadAll: () => rows.map((row) => ({ id: row.id, item: row.item })),
+    insert: (record) => {
+      const index = rows.findIndex((row) => row.id === record.id);
+      const next = { id: record.id, item: record.item };
+      if (index >= 0) {
+        rows[index] = next;
+      } else {
+        rows.push(next);
+      }
+    },
+    remove: (id) => {
+      const index = rows.findIndex((row) => row.id === id);
+      if (index >= 0) {
+        rows.splice(index, 1);
+      }
+    },
+    clear: () => {
+      rows.length = 0;
+    }
+  };
+};
+
+// src/persist/json-codec.util.ts
+var StorageCodecError = class extends Error {
+  name = "StorageCodecError";
+  cause;
+  constructor(message, cause) {
+    super(message, cause !== void 0 ? { cause } : void 0);
+    this.cause = cause;
+  }
+};
+var defaultJsonCodec = () => ({
+  serialize: (value) => JSON.stringify(value),
+  deserialize: (raw) => JSON.parse(raw)
+});
+var decodeWithCodec = (label, raw, deserialize) => {
+  try {
+    return deserialize(raw);
+  } catch (error) {
+    throw new StorageCodecError(
+      `Failed to deserialize ${label}: ${error instanceof Error ? error.message : String(error)}`,
+      error
+    );
+  }
+};
+
+// src/persist/web-storage-access.util.ts
+var getGlobalStorage = (name) => {
+  const storage = globalThis[name];
+  if (!storage) {
+    throw new Error(
+      `${name} is not available; pass an explicit \`storage\` option`
+    );
+  }
+  return storage;
+};
+var lazyGlobalStorage = (name) => ({
+  getItem: (key) => getGlobalStorage(name).getItem(key),
+  setItem: (key, value) => getGlobalStorage(name).setItem(key, value),
+  removeItem: (key) => getGlobalStorage(name).removeItem(key)
+});
+var resolveStorage = (storage) => {
+  if (storage) return storage;
+  return lazyGlobalStorage("localStorage");
+};
+
+// src/persist/web-storage.ts
+var createWebSnapshotStore = (options) => {
+  const storage = () => resolveStorage(options.storage);
+  const codec = options.codec ?? defaultJsonCodec();
+  return {
+    load: () => {
+      const raw = storage().getItem(options.key);
+      if (raw === null || raw === "") return [];
+      const items = decodeWithCodec(
+        `snapshot "${options.key}"`,
+        raw,
+        codec.deserialize
+      );
+      return Array.isArray(items) ? items : [];
+    },
+    save: (items) => {
+      storage().setItem(options.key, codec.serialize([...items]));
+    }
+  };
+};
+var orderCodec = {
+  serialize: (ids) => JSON.stringify(ids),
+  deserialize: (raw) => {
+    const ids = JSON.parse(raw);
+    if (!Array.isArray(ids)) return [];
+    return ids.filter((id) => typeof id === "string");
+  }
+};
+var createWebRowStore = (options) => {
+  const storage = () => resolveStorage(options.storage);
+  const itemCodec = options.itemCodec ?? defaultJsonCodec();
+  const orderKey = `${options.key}:order`;
+  const rowKey = (id) => `${options.key}:row:${id}`;
+  const readOrder = () => {
+    const raw = storage().getItem(orderKey);
+    if (raw === null || raw === "") return [];
+    return decodeWithCodec(
+      `row order "${orderKey}"`,
+      raw,
+      orderCodec.deserialize
+    );
+  };
+  const writeOrder = (ids) => {
+    if (ids.length === 0) {
+      storage().removeItem(orderKey);
+      return;
+    }
+    storage().setItem(orderKey, orderCodec.serialize(ids));
+  };
+  return {
+    loadAll: () => {
+      const ids = readOrder();
+      const rows = [];
+      for (const id of ids) {
+        const raw = storage().getItem(rowKey(id));
+        if (raw === null) continue;
+        rows.push({
+          id,
+          item: decodeWithCodec(
+            `row "${rowKey(id)}"`,
+            raw,
+            itemCodec.deserialize
+          )
+        });
+      }
+      return rows;
+    },
+    insert: (record) => {
+      const store = storage();
+      store.setItem(rowKey(record.id), itemCodec.serialize(record.item));
+      const ids = readOrder();
+      if (!ids.includes(record.id)) {
+        ids.push(record.id);
+        writeOrder(ids);
+      }
+    },
+    remove: (id) => {
+      const store = storage();
+      store.removeItem(rowKey(id));
+      writeOrder(readOrder().filter((entry) => entry !== id));
+    },
+    clear: () => {
+      const store = storage();
+      for (const id of readOrder()) {
+        store.removeItem(rowKey(id));
+      }
+      store.removeItem(orderKey);
+    }
+  };
+};
+var createLocalStorageSnapshotStore = (key, options = {}) => createWebSnapshotStore({
+  ...options,
+  key,
+  storage: lazyGlobalStorage("localStorage")
+});
+var createLocalStorageRowStore = (key, options = {}) => createWebRowStore({
+  ...options,
+  key,
+  storage: lazyGlobalStorage("localStorage")
+});
+var createSessionStorageSnapshotStore = (key, options = {}) => createWebSnapshotStore({
+  ...options,
+  key,
+  storage: lazyGlobalStorage("sessionStorage")
+});
+var createSessionStorageRowStore = (key, options = {}) => createWebRowStore({
+  ...options,
+  key,
+  storage: lazyGlobalStorage("sessionStorage")
+});
+
+export { StorageCodecError, createLocalStorageRowStore, createLocalStorageSnapshotStore, createMemoryRowStore, createMemorySnapshotStore, createSessionStorageRowStore, createSessionStorageSnapshotStore, createWebRowStore, createWebSnapshotStore };
+//# sourceMappingURL=chunk-SMQYICXZ.js.map
+//# sourceMappingURL=chunk-SMQYICXZ.js.map

package/dist/chunk-TX6HHN5M.js

@@ -0,0 +1,75 @@
+// src/events/index.ts
+var createTypedEmit = (emit) => {
+  return (eventName, data) => {
+    emit(eventName, data);
+  };
+};
+var buildEventEmitter = () => {
+  const listenersByEvent = /* @__PURE__ */ new Map();
+  const on = (eventName, callback) => {
+    const listeners = listenersByEvent.get(eventName);
+    if (listeners) {
+      listeners.push(callback);
+    } else {
+      listenersByEvent.set(eventName, [
+        callback
+      ]);
+    }
+    return () => off(eventName, callback);
+  };
+  const once = (eventName, callback) => {
+    const wrapper = (data) => {
+      off(eventName, wrapper);
+      callback(data);
+    };
+    return on(eventName, wrapper);
+  };
+  const off = (eventName, callback) => {
+    const listeners = listenersByEvent.get(eventName);
+    if (!listeners) return;
+    if (!callback) {
+      listenersByEvent.delete(eventName);
+      return;
+    }
+    const next = listeners.filter((cb) => cb !== callback);
+    if (next.length === 0) {
+      listenersByEvent.delete(eventName);
+    } else {
+      listenersByEvent.set(eventName, next);
+    }
+  };
+  const emit = (eventName, data) => {
+    const listeners = listenersByEvent.get(eventName);
+    if (!listeners?.length) return;
+    for (const callback of [...listeners]) {
+      try {
+        callback(data);
+      } catch {
+      }
+    }
+  };
+  const clear = () => {
+    listenersByEvent.clear();
+  };
+  const listenerCount = (eventName) => {
+    return listenersByEvent.get(eventName)?.length ?? 0;
+  };
+  const eventNames = () => {
+    return [...listenersByEvent.keys()];
+  };
+  const api = {
+    on,
+    once,
+    off,
+    emit,
+    clear,
+    listenerCount,
+    eventNames,
+    expand: () => api
+  };
+  return api;
+};
+
+export { buildEventEmitter, createTypedEmit };
+//# sourceMappingURL=chunk-TX6HHN5M.js.map
+//# sourceMappingURL=chunk-TX6HHN5M.js.map

package/dist/chunk-W3FXQZCX.js

@@ -0,0 +1,63 @@
+// src/worker/retry.ts
+var RetryExhaustedError = class extends Error {
+  name = "RetryExhaustedError";
+  attempts;
+  cause;
+  constructor(attempts, cause) {
+    super(`Retry exhausted after ${attempts} attempt(s)`, { cause });
+    this.attempts = attempts;
+    this.cause = cause;
+  }
+};
+var sleep = (ms) => new Promise((resolve) => {
+  const schedule = globalThis.setTimeout;
+  schedule(() => resolve(), ms);
+});
+var resolveDelay = (delay, failedAttempt, error) => {
+  if (delay === void 0) return 0;
+  if (typeof delay === "function") return Math.max(0, delay(failedAttempt, error));
+  return Math.max(0, delay);
+};
+var withRetry = (worker, options) => {
+  const opts = typeof options === "number" ? { retries: options } : options;
+  const maxRetries = Math.max(0, opts.retries);
+  const shouldRetry = opts.shouldRetry ?? (() => true);
+  return async (item) => {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries + 1; attempt += 1) {
+      try {
+        return await worker(item);
+      } catch (error) {
+        lastError = error;
+        const failedAttempt = attempt;
+        const retriesLeft = maxRetries + 1 - attempt;
+        if (retriesLeft <= 0 || !shouldRetry(error, failedAttempt)) {
+          throw new RetryExhaustedError(failedAttempt, error);
+        }
+        const wait = resolveDelay(opts.delay, failedAttempt, error);
+        if (wait > 0) {
+          await sleep(wait);
+        }
+      }
+    }
+    throw lastError;
+  };
+};
+
+// src/worker/pipeline.ts
+function pipeline(...steps) {
+  if (steps.length === 0) {
+    throw new Error("pipeline requires at least one step");
+  }
+  return async (input) => {
+    let value = input;
+    for (const step of steps) {
+      value = await step(value);
+    }
+    return value;
+  };
+}
+
+export { RetryExhaustedError, pipeline, withRetry };
+//# sourceMappingURL=chunk-W3FXQZCX.js.map
+//# sourceMappingURL=chunk-W3FXQZCX.js.map

package/dist/chunk-WIKDEC7T.js

@@ -0,0 +1,178 @@
+import { buildEventEmitter, createTypedEmit } from './chunk-TX6HHN5M.js';
+
+// src/router/match.util.ts
+var TOPIC_SEPARATOR = ".";
+var SINGLE_WILDCARD = "*";
+var MULTI_WILDCARD = "#";
+var isEmptySegment = (segment) => segment.length === 0;
+var isValidTopic = (topic) => {
+  if (topic.length === 0) return false;
+  if (topic.includes(SINGLE_WILDCARD) || topic.includes(MULTI_WILDCARD)) {
+    return false;
+  }
+  const segments = topic.split(TOPIC_SEPARATOR);
+  return segments.length > 0 && !segments.some(isEmptySegment);
+};
+var isValidPattern = (pattern) => {
+  if (pattern.length === 0) return false;
+  const segments = pattern.split(TOPIC_SEPARATOR);
+  if (segments.some(isEmptySegment)) return false;
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i];
+    if (segment === MULTI_WILDCARD) {
+      return i === segments.length - 1;
+    }
+  }
+  return true;
+};
+var matchTopic = (pattern, topic) => {
+  if (!isValidPattern(pattern) || !isValidTopic(topic)) return false;
+  const patternParts = pattern.split(TOPIC_SEPARATOR);
+  const topicParts = topic.split(TOPIC_SEPARATOR);
+  let pi = 0;
+  let ti = 0;
+  while (pi < patternParts.length && ti < topicParts.length) {
+    const token = patternParts[pi];
+    if (token === MULTI_WILDCARD) {
+      return true;
+    }
+    if (token === SINGLE_WILDCARD || token === topicParts[ti]) {
+      pi += 1;
+      ti += 1;
+      continue;
+    }
+    return false;
+  }
+  if (pi === patternParts.length - 1 && patternParts[pi] === MULTI_WILDCARD) {
+    return true;
+  }
+  return pi === patternParts.length && ti === topicParts.length;
+};
+
+// src/router/router.ts
+var buildRouter = (options = {}) => {
+  const events = buildEventEmitter();
+  const emitRouter = createTypedEmit(
+    events.emit
+  );
+  const routes = [];
+  let unmatchedTarget = options.unmatchedTarget;
+  let unmatchedTotal = 0;
+  let lastUnmatchedRecord;
+  const bind = (pattern, target) => {
+    if (!isValidPattern(pattern)) {
+      const error = new Error(`Invalid route pattern: ${pattern}`);
+      emitRouter("router:error", { operation: "bind", error, pattern });
+      throw error;
+    }
+    const binding = {
+      pattern,
+      target
+    };
+    routes.push(binding);
+    emitRouter("router:bound", { pattern });
+    return () => {
+      unbind(pattern, target);
+    };
+  };
+  const unbind = (pattern, target) => {
+    let removed = 0;
+    for (let i = routes.length - 1; i >= 0; i -= 1) {
+      const route = routes[i];
+      if (route.pattern !== pattern) continue;
+      if (target !== void 0 && route.target !== target) continue;
+      routes.splice(i, 1);
+      removed += 1;
+    }
+    if (removed > 0) {
+      emitRouter("router:unbound", { pattern, removed });
+    }
+  };
+  const deliverUnmatched = (topic, data) => {
+    if (unmatchedTarget === void 0) {
+      return false;
+    }
+    try {
+      unmatchedTarget.enqueue({ topic, data });
+      return true;
+    } catch (error) {
+      emitRouter("router:error", {
+        operation: "unmatched",
+        error,
+        topic
+      });
+      return false;
+    }
+  };
+  const publish = (topic, data) => {
+    if (!isValidTopic(topic)) {
+      const error = new Error(`Invalid publish topic: ${topic}`);
+      emitRouter("router:error", { operation: "publish", error, topic });
+      throw error;
+    }
+    const message = { topic, data };
+    let matched = 0;
+    for (const route of [...routes]) {
+      if (!matchTopic(route.pattern, topic)) continue;
+      try {
+        route.target.enqueue(message);
+        matched += 1;
+      } catch (error) {
+        emitRouter("router:error", {
+          operation: "publish",
+          error,
+          topic,
+          pattern: route.pattern
+        });
+      }
+    }
+    if (matched === 0) {
+      unmatchedTotal += 1;
+      lastUnmatchedRecord = { topic, data };
+      const delivered = deliverUnmatched(topic, data);
+      emitRouter("router:unmatched", { topic, data, delivered });
+    } else {
+      emitRouter("router:published", { topic, data, matched });
+    }
+    return matched;
+  };
+  const bindings = () => routes.map((route) => ({
+    pattern: route.pattern,
+    target: route.target
+  }));
+  const clear = () => {
+    routes.length = 0;
+  };
+  const setUnmatchedTarget = (target) => {
+    unmatchedTarget = target;
+  };
+  const getUnmatchedTarget = () => unmatchedTarget;
+  const unmatchedCount = () => unmatchedTotal;
+  const lastUnmatched = () => lastUnmatchedRecord;
+  const clearUnmatched = () => {
+    unmatchedTotal = 0;
+    lastUnmatchedRecord = void 0;
+  };
+  const api = {
+    bind,
+    unbind,
+    publish,
+    bindings,
+    clear,
+    setUnmatchedTarget,
+    getUnmatchedTarget,
+    unmatchedCount,
+    lastUnmatched,
+    clearUnmatched,
+    on: events.on,
+    once: events.once,
+    off: events.off,
+    emit: events.emit,
+    expand: () => api
+  };
+  return api;
+};
+
+export { MULTI_WILDCARD, SINGLE_WILDCARD, TOPIC_SEPARATOR, buildRouter, isValidPattern, isValidTopic, matchTopic };
+//# sourceMappingURL=chunk-WIKDEC7T.js.map
+//# sourceMappingURL=chunk-WIKDEC7T.js.map

package/dist/config/index.js

@@ -0,0 +1,7 @@
+export { buildFromConfig, buildFromJson, defineConfig, parseSystemConfig, validateJsConfig, validateSystemConfig } from '../chunk-R2ONNABJ.js';
+import '../chunk-SMQYICXZ.js';
+import '../chunk-653YYS22.js';
+import '../chunk-WIKDEC7T.js';
+import '../chunk-TX6HHN5M.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/events/index.js

@@ -0,0 +1,3 @@
+export { buildEventEmitter, createTypedEmit } from '../chunk-TX6HHN5M.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map