r-agency-mesh-client-v1 1.0.3

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "r-agency-mesh-client-v1",
+  "author": "Jonny Becker",
+  "version": "1.0.3",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "release": "tsup"
+  },
+  "devDependencies": {
+    "typescript": "~5.7.2",
+    "vite": "^6.2.0",
+    "tsup": "^8.4.0",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1"
+  },
+  "dependencies": {
+    "axios": "^1.8.4",
+    "short-unique-id": "^5.2.2",
+    "zod": "^3.24.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/release/index.cjs

@@ -0,0 +1,207 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// src/classes/client/mesh.client.ts
+var _axios = require('axios'); var _axios2 = _interopRequireDefault(_axios);
+
+// src/helper/url.ts
+var mapping = {
+  connect: "connect"
+};
+var createMeshUrl = (host, port, type) => {
+  const path = _nullishCoalesce(mapping[type], () => ( void 0));
+  if (!path) {
+    return void 0;
+  }
+  return new URL([`${host}:${port}`, path].join("/"));
+};
+
+// src/helper/client-id.ts
+var hasMashClientId = () => {
+  return !!window.localStorage.getItem("mesh-client-id");
+};
+var setMeshClientId = (id) => {
+  const item = {
+    id,
+    date: (/* @__PURE__ */ new Date()).getTime()
+  };
+  window.localStorage.setItem("mesh-client-id", JSON.stringify(item));
+};
+var getMeshClientId = () => {
+  try {
+    const json = window.localStorage.getItem("mesh-client-id");
+    if (!json) {
+      return void 0;
+    }
+    return JSON.parse(json);
+  } catch (e) {
+    return void 0;
+  }
+};
+
+// src/classes/client/mesh.client.ts
+var _zod = require('zod');
+
+// src/classes/event-manager/event.manager.ts
+var EventManager = (_class = class {constructor() { _class.prototype.__init.call(this); }
+  __init() {this.listeners = {}}
+  on(eventName, listener) {
+    this.listeners[eventName] ??= [];
+    _optionalChain([this, 'access', _ => _.listeners, 'access', _2 => _2[eventName], 'optionalAccess', _3 => _3.push, 'call', _4 => _4(listener)]);
+    return () => {
+      this.off(eventName, listener);
+    };
+  }
+  off(eventName, listener) {
+    this.listeners[eventName] ??= [];
+    this.listeners[eventName] = _optionalChain([this, 'access', _5 => _5.listeners, 'access', _6 => _6[eventName], 'optionalAccess', _7 => _7.filter, 'call', _8 => _8(
+      (l) => l !== listener
+    )]);
+  }
+  emit(eventName, payload) {
+    this.listeners[eventName] ??= [];
+    _optionalChain([this, 'access', _9 => _9.listeners, 'access', _10 => _10[eventName], 'optionalAccess', _11 => _11.forEach, 'call', _12 => _12((listener) => listener(payload))]);
+  }
+}, _class);
+
+// src/helper/message.ts
+var parseIncomingMessage = (event) => {
+  const type = Object.prototype.toString.call(event.data);
+  try {
+    switch (type) {
+      case "[object ArrayBuffer]":
+        return {
+          type,
+          data: JSON.parse(new TextDecoder().decode(event.data))
+        };
+    }
+    return {
+      type
+    };
+  } catch (e) {
+    return {
+      type,
+      error: e
+    };
+  }
+};
+
+// src/classes/websocket/web.socket.client.ts
+var WebSocketClient = (_class2 = class {
+  __init2() {this.websocket = void 0}
+  constructor() {;_class2.prototype.__init2.call(this);
+  }
+  connect(config, clientId) {
+    const url = new URL(config.websocket.url);
+    url.searchParams.set("token", JSON.stringify({
+      version: "1.0",
+      clientId
+    }));
+    const websocket = new WebSocket(url.toString());
+    websocket.binaryType = "arraybuffer";
+    websocket.addEventListener("open", this.open.bind(this));
+    websocket.addEventListener("close", this.close.bind(this));
+    websocket.addEventListener("message", this.message.bind(this));
+    this.websocket = websocket;
+  }
+  send(payload) {
+    try {
+      const encoder = new TextEncoder();
+      const encoded = encoder.encode(JSON.stringify(payload));
+      _optionalChain([this, 'access', _13 => _13.websocket, 'optionalAccess', _14 => _14.send, 'call', _15 => _15(encoded)]);
+    } catch (e) {
+      const error = e;
+      console.log(error.message);
+    }
+  }
+  message(event) {
+    const message = parseIncomingMessage(event);
+    const data = _nullishCoalesce(message.data, () => ( {}));
+    if (data.ping) {
+      return this.send({
+        pong: true
+      });
+    }
+  }
+  open() {
+    this.send({});
+  }
+  close() {
+  }
+}, _class2);
+
+// src/classes/client/mesh.client.ts
+var MeshClient = (_class3 = class {
+  constructor(config) {;_class3.prototype.__init3.call(this);
+    this.config = config;
+    this.websocket = new WebSocketClient();
+  }
+  __init3() {this.events = new EventManager()}
+  
+  connect() {
+    return new Promise((resolve) => {
+      const validation = _zod.z.object({
+        host: _zod.z.string().url(),
+        port: _zod.z.number()
+      }).safeParse({
+        host: this.config.host,
+        port: this.config.port
+      });
+      if (!validation.success) {
+        throw new Error("invalid config schema!");
+      }
+      const url = createMeshUrl(this.config.host, this.config.port, "connect");
+      if (!url) {
+        throw new Error("mesh connect url not found!");
+      }
+      _axios2.default.request({
+        method: "post",
+        url: url.toString(),
+        headers: {
+          ..._nullishCoalesce(this.config.headers, () => ( {})),
+          ...{
+            "x-mesh-host": new URL(this.config.host).host,
+            "x-mesh-client-id": _optionalChain([getMeshClientId, 'call', _16 => _16(), 'optionalAccess', _17 => _17.id])
+          }
+        }
+      }).then((response) => {
+        this.connected(response.data);
+        resolve();
+      }).catch(() => {
+        throw new Error("connection to mesh-server failed!");
+      });
+    });
+  }
+  connected(response) {
+    const success = _nullishCoalesce(response.success, () => ( false));
+    const config = response.config;
+    const clientId = response.clientId;
+    if (!success || !config || !clientId) {
+      throw new Error("mesh client config not loaded!");
+    }
+    if (!hasMashClientId()) {
+      setMeshClientId(clientId);
+    }
+    this.events.emit("connected", {
+      config
+    });
+    this.websocket.connect(config, clientId);
+  }
+}, _class3);
+
+// src/index.ts
+var useMeshClient = () => {
+  const createClient = (config) => {
+    if (!window.MeshClient) {
+      window.MeshClient = new MeshClient(config);
+    }
+    return window.MeshClient;
+  };
+  return {
+    createClient
+  };
+};
+var createMeshClient = (config) => {
+  return new MeshClient(config);
+};
+
+
+
+exports.createMeshClient = createMeshClient; exports.useMeshClient = useMeshClient;

package/release/index.d.cts

@@ -0,0 +1,47 @@
+interface IMeshClientCreateConfig {
+    host: string;
+    port: number;
+    headers?: Record<string, any>;
+}
+declare global {
+    interface Window {
+        MeshClient: IMeshClient;
+    }
+}
+
+type EventMap = {
+    [eventName: string]: any;
+};
+type off = () => void;
+interface EventManagerInt<Events extends EventMap> {
+    on<K extends keyof Events>(eventName: K, listener: (payload: Events[K]) => void): off;
+    off<K extends keyof Events>(eventName: K, listener: (payload: Events[K]) => void): void;
+    emit<K extends keyof Events>(eventName: K, payload?: Events[K]): void;
+}
+
+interface IMeshClientConfig {
+    graphql: {
+        url: string;
+    };
+    websocket: {
+        url: string;
+    };
+}
+
+type MeshClientEvents = {
+    connected: {
+        config: IMeshClientConfig;
+    };
+};
+
+interface IMeshClient {
+    events: EventManagerInt<MeshClientEvents>;
+    connect(): Promise<void>;
+}
+
+declare const useMeshClient: () => {
+    createClient: (config: IMeshClientCreateConfig) => IMeshClient;
+};
+declare const createMeshClient: (config: IMeshClientCreateConfig) => IMeshClient;
+
+export { createMeshClient, useMeshClient };

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": [
+      "ES2020",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": [
+    "src"
+  ]
+}