@rg-dev/tzevaadom-api 1.0.0

package/dist/index.cjs

@@ -0,0 +1,540 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(src_exports);
+var import_ws = __toESM(require("ws"), 1);
+
+// node_modules/emittery/maps.js
+var anyMap = /* @__PURE__ */ new WeakMap();
+var eventsMap = /* @__PURE__ */ new WeakMap();
+var producersMap = /* @__PURE__ */ new WeakMap();
+
+// node_modules/emittery/index.js
+var anyProducer = Symbol("anyProducer");
+var resolvedPromise = Promise.resolve();
+var listenerAdded = Symbol("listenerAdded");
+var listenerRemoved = Symbol("listenerRemoved");
+var canEmitMetaEvents = false;
+var isGlobalDebugEnabled = false;
+var isEventKeyType = (key) => typeof key === "string" || typeof key === "symbol" || typeof key === "number";
+function assertEventName(eventName) {
+  if (!isEventKeyType(eventName)) {
+    throw new TypeError("`eventName` must be a string, symbol, or number");
+  }
+}
+function assertListener(listener) {
+  if (typeof listener !== "function") {
+    throw new TypeError("listener must be a function");
+  }
+}
+function getListeners(instance, eventName) {
+  const events = eventsMap.get(instance);
+  if (!events.has(eventName)) {
+    return;
+  }
+  return events.get(eventName);
+}
+function getEventProducers(instance, eventName) {
+  const key = isEventKeyType(eventName) ? eventName : anyProducer;
+  const producers = producersMap.get(instance);
+  if (!producers.has(key)) {
+    return;
+  }
+  return producers.get(key);
+}
+function enqueueProducers(instance, eventName, eventData) {
+  const producers = producersMap.get(instance);
+  if (producers.has(eventName)) {
+    for (const producer of producers.get(eventName)) {
+      producer.enqueue(eventData);
+    }
+  }
+  if (producers.has(anyProducer)) {
+    const item = Promise.all([eventName, eventData]);
+    for (const producer of producers.get(anyProducer)) {
+      producer.enqueue(item);
+    }
+  }
+}
+function iterator(instance, eventNames) {
+  eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+  let isFinished = false;
+  let flush = () => {
+  };
+  let queue = [];
+  const producer = {
+    enqueue(item) {
+      queue.push(item);
+      flush();
+    },
+    finish() {
+      isFinished = true;
+      flush();
+    }
+  };
+  for (const eventName of eventNames) {
+    let set = getEventProducers(instance, eventName);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      const producers = producersMap.get(instance);
+      producers.set(eventName, set);
+    }
+    set.add(producer);
+  }
+  return {
+    async next() {
+      if (!queue) {
+        return { done: true };
+      }
+      if (queue.length === 0) {
+        if (isFinished) {
+          queue = void 0;
+          return this.next();
+        }
+        await new Promise((resolve) => {
+          flush = resolve;
+        });
+        return this.next();
+      }
+      return {
+        done: false,
+        value: await queue.shift()
+      };
+    },
+    async return(value) {
+      queue = void 0;
+      for (const eventName of eventNames) {
+        const set = getEventProducers(instance, eventName);
+        if (set) {
+          set.delete(producer);
+          if (set.size === 0) {
+            const producers = producersMap.get(instance);
+            producers.delete(eventName);
+          }
+        }
+      }
+      flush();
+      return arguments.length > 0 ? { done: true, value: await value } : { done: true };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function defaultMethodNamesOrAssert(methodNames) {
+  if (methodNames === void 0) {
+    return allEmitteryMethods;
+  }
+  if (!Array.isArray(methodNames)) {
+    throw new TypeError("`methodNames` must be an array of strings");
+  }
+  for (const methodName of methodNames) {
+    if (!allEmitteryMethods.includes(methodName)) {
+      if (typeof methodName !== "string") {
+        throw new TypeError("`methodNames` element must be a string");
+      }
+      throw new Error(`${methodName} is not Emittery method`);
+    }
+  }
+  return methodNames;
+}
+var isMetaEvent = (eventName) => eventName === listenerAdded || eventName === listenerRemoved;
+function emitMetaEvent(emitter, eventName, eventData) {
+  if (!isMetaEvent(eventName)) {
+    return;
+  }
+  try {
+    canEmitMetaEvents = true;
+    emitter.emit(eventName, eventData);
+  } finally {
+    canEmitMetaEvents = false;
+  }
+}
+var Emittery = class _Emittery {
+  static mixin(emitteryPropertyName, methodNames) {
+    methodNames = defaultMethodNamesOrAssert(methodNames);
+    return (target) => {
+      if (typeof target !== "function") {
+        throw new TypeError("`target` must be function");
+      }
+      for (const methodName of methodNames) {
+        if (target.prototype[methodName] !== void 0) {
+          throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+        }
+      }
+      function getEmitteryProperty() {
+        Object.defineProperty(this, emitteryPropertyName, {
+          enumerable: false,
+          value: new _Emittery()
+        });
+        return this[emitteryPropertyName];
+      }
+      Object.defineProperty(target.prototype, emitteryPropertyName, {
+        enumerable: false,
+        get: getEmitteryProperty
+      });
+      const emitteryMethodCaller = (methodName) => function(...args) {
+        return this[emitteryPropertyName][methodName](...args);
+      };
+      for (const methodName of methodNames) {
+        Object.defineProperty(target.prototype, methodName, {
+          enumerable: false,
+          value: emitteryMethodCaller(methodName)
+        });
+      }
+      return target;
+    };
+  }
+  static get isDebugEnabled() {
+    var _a;
+    if (typeof ((_a = globalThis.process) == null ? void 0 : _a.env) !== "object") {
+      return isGlobalDebugEnabled;
+    }
+    const { env } = globalThis.process ?? { env: {} };
+    return env.DEBUG === "emittery" || env.DEBUG === "*" || isGlobalDebugEnabled;
+  }
+  static set isDebugEnabled(newValue) {
+    isGlobalDebugEnabled = newValue;
+  }
+  constructor(options = {}) {
+    anyMap.set(this, /* @__PURE__ */ new Set());
+    eventsMap.set(this, /* @__PURE__ */ new Map());
+    producersMap.set(this, /* @__PURE__ */ new Map());
+    producersMap.get(this).set(anyProducer, /* @__PURE__ */ new Set());
+    this.debug = options.debug ?? {};
+    if (this.debug.enabled === void 0) {
+      this.debug.enabled = false;
+    }
+    if (!this.debug.logger) {
+      this.debug.logger = (type, debugName, eventName, eventData) => {
+        try {
+          eventData = JSON.stringify(eventData);
+        } catch {
+          eventData = `Object with the following keys failed to stringify: ${Object.keys(eventData).join(",")}`;
+        }
+        if (typeof eventName === "symbol" || typeof eventName === "number") {
+          eventName = eventName.toString();
+        }
+        const currentTime = /* @__PURE__ */ new Date();
+        const logTime = `${currentTime.getHours()}:${currentTime.getMinutes()}:${currentTime.getSeconds()}.${currentTime.getMilliseconds()}`;
+        console.log(`[${logTime}][emittery:${type}][${debugName}] Event Name: ${eventName}
+	data: ${eventData}`);
+      };
+    }
+  }
+  logIfDebugEnabled(type, eventName, eventData) {
+    if (_Emittery.isDebugEnabled || this.debug.enabled) {
+      this.debug.logger(type, this.debug.name, eventName, eventData);
+    }
+  }
+  on(eventNames, listener, { signal } = {}) {
+    assertListener(listener);
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNames) {
+      assertEventName(eventName);
+      let set = getListeners(this, eventName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        const events = eventsMap.get(this);
+        events.set(eventName, set);
+      }
+      set.add(listener);
+      this.logIfDebugEnabled("subscribe", eventName, void 0);
+      if (!isMetaEvent(eventName)) {
+        emitMetaEvent(this, listenerAdded, { eventName, listener });
+      }
+    }
+    const off = () => {
+      this.off(eventNames, listener);
+      signal == null ? void 0 : signal.removeEventListener("abort", off);
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", off, { once: true });
+    if (signal == null ? void 0 : signal.aborted) {
+      off();
+    }
+    return off;
+  }
+  off(eventNames, listener) {
+    assertListener(listener);
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNames) {
+      assertEventName(eventName);
+      const set = getListeners(this, eventName);
+      if (set) {
+        set.delete(listener);
+        if (set.size === 0) {
+          const events = eventsMap.get(this);
+          events.delete(eventName);
+        }
+      }
+      this.logIfDebugEnabled("unsubscribe", eventName, void 0);
+      if (!isMetaEvent(eventName)) {
+        emitMetaEvent(this, listenerRemoved, { eventName, listener });
+      }
+    }
+  }
+  once(eventNames, predicate) {
+    if (predicate !== void 0 && typeof predicate !== "function") {
+      throw new TypeError("predicate must be a function");
+    }
+    let off_;
+    const promise = new Promise((resolve) => {
+      off_ = this.on(eventNames, (data) => {
+        if (predicate && !predicate(data)) {
+          return;
+        }
+        off_();
+        resolve(data);
+      });
+    });
+    promise.off = off_;
+    return promise;
+  }
+  events(eventNames) {
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNames) {
+      assertEventName(eventName);
+    }
+    return iterator(this, eventNames);
+  }
+  async emit(eventName, eventData) {
+    assertEventName(eventName);
+    if (isMetaEvent(eventName) && !canEmitMetaEvents) {
+      throw new TypeError("`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`");
+    }
+    this.logIfDebugEnabled("emit", eventName, eventData);
+    enqueueProducers(this, eventName, eventData);
+    const listeners = getListeners(this, eventName) ?? /* @__PURE__ */ new Set();
+    const anyListeners = anyMap.get(this);
+    const staticListeners = [...listeners];
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
+    await resolvedPromise;
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        if (listeners.has(listener)) {
+          return listener(eventData);
+        }
+      }),
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          return listener(eventName, eventData);
+        }
+      })
+    ]);
+  }
+  async emitSerial(eventName, eventData) {
+    assertEventName(eventName);
+    if (isMetaEvent(eventName) && !canEmitMetaEvents) {
+      throw new TypeError("`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`");
+    }
+    this.logIfDebugEnabled("emitSerial", eventName, eventData);
+    enqueueProducers(this, eventName, eventData);
+    const listeners = getListeners(this, eventName) ?? /* @__PURE__ */ new Set();
+    const anyListeners = anyMap.get(this);
+    const staticListeners = [...listeners];
+    const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
+    await resolvedPromise;
+    for (const listener of staticListeners) {
+      if (listeners.has(listener)) {
+        await listener(eventData);
+      }
+    }
+    for (const listener of staticAnyListeners) {
+      if (anyListeners.has(listener)) {
+        await listener(eventName, eventData);
+      }
+    }
+  }
+  onAny(listener, { signal } = {}) {
+    assertListener(listener);
+    this.logIfDebugEnabled("subscribeAny", void 0, void 0);
+    anyMap.get(this).add(listener);
+    emitMetaEvent(this, listenerAdded, { listener });
+    const offAny = () => {
+      this.offAny(listener);
+      signal == null ? void 0 : signal.removeEventListener("abort", offAny);
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", offAny, { once: true });
+    if (signal == null ? void 0 : signal.aborted) {
+      offAny();
+    }
+    return offAny;
+  }
+  anyEvent() {
+    return iterator(this);
+  }
+  offAny(listener) {
+    assertListener(listener);
+    this.logIfDebugEnabled("unsubscribeAny", void 0, void 0);
+    emitMetaEvent(this, listenerRemoved, { listener });
+    anyMap.get(this).delete(listener);
+  }
+  clearListeners(eventNames) {
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNames) {
+      this.logIfDebugEnabled("clear", eventName, void 0);
+      if (isEventKeyType(eventName)) {
+        const set = getListeners(this, eventName);
+        if (set) {
+          set.clear();
+        }
+        const producers = getEventProducers(this, eventName);
+        if (producers) {
+          for (const producer of producers) {
+            producer.finish();
+          }
+          producers.clear();
+        }
+      } else {
+        anyMap.get(this).clear();
+        for (const [eventName2, listeners] of eventsMap.get(this).entries()) {
+          listeners.clear();
+          eventsMap.get(this).delete(eventName2);
+        }
+        for (const [eventName2, producers] of producersMap.get(this).entries()) {
+          for (const producer of producers) {
+            producer.finish();
+          }
+          producers.clear();
+          producersMap.get(this).delete(eventName2);
+        }
+      }
+    }
+  }
+  listenerCount(eventNames) {
+    var _a, _b, _c;
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    let count = 0;
+    for (const eventName of eventNames) {
+      if (isEventKeyType(eventName)) {
+        count += anyMap.get(this).size + (((_a = getListeners(this, eventName)) == null ? void 0 : _a.size) ?? 0) + (((_b = getEventProducers(this, eventName)) == null ? void 0 : _b.size) ?? 0) + (((_c = getEventProducers(this)) == null ? void 0 : _c.size) ?? 0);
+        continue;
+      }
+      if (eventName !== void 0) {
+        assertEventName(eventName);
+      }
+      count += anyMap.get(this).size;
+      for (const value of eventsMap.get(this).values()) {
+        count += value.size;
+      }
+      for (const value of producersMap.get(this).values()) {
+        count += value.size;
+      }
+    }
+    return count;
+  }
+  bindMethods(target, methodNames) {
+    if (typeof target !== "object" || target === null) {
+      throw new TypeError("`target` must be an object");
+    }
+    methodNames = defaultMethodNamesOrAssert(methodNames);
+    for (const methodName of methodNames) {
+      if (target[methodName] !== void 0) {
+        throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+      }
+      Object.defineProperty(target, methodName, {
+        enumerable: false,
+        value: this[methodName].bind(this)
+      });
+    }
+  }
+};
+var allEmitteryMethods = Object.getOwnPropertyNames(Emittery.prototype).filter((v) => v !== "constructor");
+Object.defineProperty(Emittery, "listenerAdded", {
+  value: listenerAdded,
+  writable: false,
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Emittery, "listenerRemoved", {
+  value: listenerRemoved,
+  writable: false,
+  enumerable: true,
+  configurable: false
+});
+
+// src/index.ts
+var WS_URL = "wss://ws.tzevaadom.co.il/socket?platform=WEB";
+var HEADERS = { Origin: "https://www.tzevaadom.co.il" };
+var MAX_DELAY = 1e4;
+var TzevaadomClient = class extends Emittery {
+  attempt = 0;
+  ws = null;
+  constructor() {
+    super();
+    this.connect();
+  }
+  connect() {
+    this.ws = new import_ws.default(WS_URL, { headers: HEADERS });
+    this.ws.on("open", () => {
+      this.attempt = 0;
+      this.emit("connected", void 0);
+    });
+    this.ws.on("message", (raw) => {
+      if (typeof raw !== "string" && !Buffer.isBuffer(raw))
+        return;
+      try {
+        const { type, data } = JSON.parse(raw.toString());
+        this.emit(type, data);
+      } catch {
+      }
+    });
+    this.ws.on(
+      "error",
+      (err) => {
+        console.error("ws error", err);
+        this.emit("error", err);
+      }
+    );
+    this.ws.on(
+      "close",
+      (code) => {
+        const delay = Math.min(1e3 * 2 ** this.attempt++, MAX_DELAY);
+        this.emit("disconnected", void 0);
+        console.log(`Closed (${code}) \u2014 reconnecting in ${delay}ms...`);
+        setTimeout(() => this.connect(), delay);
+      }
+    );
+  }
+  disconnect() {
+    var _a, _b;
+    (_a = this.ws) == null ? void 0 : _a.removeAllListeners();
+    (_b = this.ws) == null ? void 0 : _b.close();
+    this.ws = null;
+  }
+};
+var createClient = () => new TzevaadomClient();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createClient
+});

package/dist/index.d.cts

@@ -0,0 +1,56 @@
+import Emittery from 'emittery';
+
+interface AlertData {
+    notificationId: string;
+    time: number;
+    threat: number;
+    isDrill: boolean;
+    cities: string[];
+}
+interface ListsVersionsData {
+    [key: string]: unknown;
+}
+interface SystemMessageData {
+    id: number;
+    time: string;
+    titleHe: string;
+    titleAr: string;
+    titleEn: string;
+    titleEs: string;
+    titleRu: string;
+    bodyHe: string;
+    bodyAr: string;
+    bodyEn: string;
+    bodyEs: string;
+    bodyRu: string;
+    forIos: boolean;
+    forAndroid: boolean;
+    display: boolean;
+    untilVersionIos: string | null;
+    untilVersionAndroid: string | null;
+    instruction: boolean;
+    areasIds: number[];
+    citiesIds: number[];
+    instructionType: number;
+    pinUntil: string | null;
+    notificationId: string;
+    instructionReadingDescName: string;
+}
+type EventMap = {
+    ALERT: AlertData;
+    LISTS_VERSIONS: ListsVersionsData;
+    SYSTEM_MESSAGE: SystemMessageData;
+    connected: undefined;
+    disconnected: undefined;
+    error: Error;
+};
+declare class TzevaadomClient extends Emittery<EventMap> {
+    private attempt;
+    private ws;
+    constructor();
+    private connect;
+    disconnect(): void;
+}
+declare const createClient: () => TzevaadomClient;
+
+export { type AlertData, type ListsVersionsData, type SystemMessageData, createClient };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@rg-dev/tzevaadom-api",
+  "version": "1.0.0",
+  "description": "",
+  "scripts": {
+    "test": "tsup && node dist/index.cjs",
+    "build": "tsup"
+  },
+  "author": "",
+  "license": "ISC",
+  "main": "./dist/index.cjs",
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^14.18.36",
+    "@types/ws": "^8.18.1",
+    "builtin-modules": "^3.3.0",
+    "execa": "^8.0.1",
+    "tsup": "^8.0.2",
+    "emittery": "^1.2.1",
+
+    "typescript": "^5.4.5"
+  },
+    "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ws": "^8.19.0"
+  }
+}