@akanjs/signal 0.0.45 → 0.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/signal",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -16,10 +16,8 @@
   },
   "dependencies": {
     "@urql/core": "^5.1.0",
-    "dayjs": "^1.11.13",
     "immer": "^10.1.1",
     "next": "^15.3.2",
-    "pluralize": "^8.0.0",
     "reflect-metadata": "^0.2.2",
     "socket.io-client": "^4.8.1"
   }

package/src/baseFetch.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var baseFetch_exports = {};
+__export(baseFetch_exports, {
+  baseFetch: () => baseFetch
+});
+module.exports = __toCommonJS(baseFetch_exports);
+var import_client = require("./client");
+const nativeFetch = fetch;
+const baseFetch = Object.assign(nativeFetch, {
+  client: import_client.client,
+  clone: function(option = {}) {
+    return {
+      ...this,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+      client: this.client.clone(option)
+    };
+  }
+});

package/src/client.js

@@ -0,0 +1,164 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  client: () => client
+});
+module.exports = __toCommonJS(client_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_core = require("@urql/core");
+var import_socket = require("socket.io-client");
+class SocketIo {
+  socket;
+  roomSubscribeMap = /* @__PURE__ */ new Map();
+  constructor(uri) {
+    this.socket = (0, import_socket.io)(uri, { transports: ["websocket"] });
+    this.socket.on("connect", () => {
+      this.roomSubscribeMap.forEach((option) => {
+        this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+      });
+    });
+  }
+  on(event, callback) {
+    this.socket.on(event, callback);
+  }
+  removeListener(event, callback) {
+    this.socket.removeListener(event, callback);
+  }
+  removeAllListeners() {
+    this.socket.removeAllListeners();
+  }
+  hasListeners(event) {
+    return this.socket.hasListeners(event);
+  }
+  emit(key, data) {
+    this.socket.emit(key, data);
+  }
+  subscribe(option) {
+    if (!this.roomSubscribeMap.has(option.roomId)) {
+      this.roomSubscribeMap.set(option.roomId, option);
+      this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+    }
+    this.socket.on(option.roomId, option.handleEvent);
+  }
+  unsubscribe(roomId, handleEvent) {
+    this.socket.removeListener(roomId, handleEvent);
+    const option = this.roomSubscribeMap.get(roomId);
+    if (this.hasListeners(roomId) || !option)
+      return;
+    this.roomSubscribeMap.delete(roomId);
+    this.socket.emit(option.key, { ...option.message, __subscribe__: false });
+  }
+  disconnect() {
+    this.socket.disconnect();
+    return this;
+  }
+}
+class Client {
+  static globalIoMap = /* @__PURE__ */ new Map();
+  static tokenStore = /* @__PURE__ */ new Map();
+  async waitUntilWebSocketConnected(ws = import_base.baseClientEnv.serverWsUri) {
+    if (import_base.baseClientEnv.side === "server")
+      return true;
+    while (!this.getIo(ws).socket.connected) {
+      import_common.Logger.verbose("waiting for websocket to initialize...");
+      await (0, import_common.sleep)(300);
+    }
+  }
+  isInitialized = false;
+  uri = import_base.baseClientEnv.serverGraphqlUri;
+  ws = import_base.baseClientEnv.serverWsUri;
+  udp = null;
+  gql = (0, import_core.createClient)({ url: this.uri, fetch, exchanges: [import_core.cacheExchange, import_core.fetchExchange] });
+  jwt = null;
+  async getJwt() {
+    const isNextServer = import_base.baseClientEnv.side === "server" && import_base.baseEnv.operationType === "client";
+    if (isNextServer) {
+      const nextHeaders = require("next/headers");
+      return (await nextHeaders.cookies?.())?.get("jwt")?.value ?? (await nextHeaders.headers?.())?.get("jwt") ?? this.jwt ?? null;
+    } else
+      return Client.tokenStore.get(this) ?? null;
+  }
+  io = null;
+  init(data = {}) {
+    Object.assign(this, data);
+    this.setLink(data.uri);
+    this.setIo(data.ws);
+    this.isInitialized = true;
+  }
+  setIo(ws = import_base.baseClientEnv.serverWsUri) {
+    this.ws = ws;
+    const existingIo = Client.globalIoMap.get(ws);
+    if (existingIo) {
+      this.io = existingIo;
+      return;
+    }
+    this.io = new SocketIo(ws);
+    Client.globalIoMap.set(ws, this.io);
+  }
+  getIo(ws = import_base.baseClientEnv.serverWsUri) {
+    const existingIo = Client.globalIoMap.get(ws);
+    if (existingIo)
+      return existingIo;
+    const io2 = new SocketIo(ws);
+    Client.globalIoMap.set(ws, io2);
+    return io2;
+  }
+  setLink(uri = import_base.baseClientEnv.serverGraphqlUri) {
+    this.uri = uri;
+    this.gql = (0, import_core.createClient)({
+      url: this.uri,
+      fetch,
+      exchanges: [import_core.cacheExchange, import_core.fetchExchange],
+      // requestPolicy: "network-only",
+      fetchOptions: () => {
+        return {
+          headers: {
+            "apollo-require-preflight": "true",
+            ...this.jwt ? { authorization: `Bearer ${this.jwt}` } : {}
+          }
+        };
+      }
+    });
+  }
+  setJwt(jwt) {
+    Client.tokenStore.set(this, jwt);
+  }
+  reset() {
+    this.io?.disconnect();
+    this.io = null;
+    this.jwt = null;
+  }
+  clone(data = {}) {
+    const newClient = new Client();
+    newClient.init({ ...this, ...data });
+    if (data.jwt)
+      Client.tokenStore.set(newClient, data.jwt);
+    return newClient;
+  }
+  terminate() {
+    this.reset();
+    Client.globalIoMap.forEach((io2) => io2.disconnect());
+    this.isInitialized = false;
+  }
+  setUdp(udp) {
+    this.udp = udp;
+  }
+}
+const client = new Client();

package/src/doc.js

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var doc_exports = {};
+__export(doc_exports, {
+  getExampleData: () => getExampleData,
+  makeRequestExample: () => makeRequestExample,
+  makeResponseExample: () => makeResponseExample
+});
+module.exports = __toCommonJS(doc_exports);
+var import_base = require("@akanjs/base");
+var import_constant = require("@akanjs/constant");
+var import_signalDecorators = require("./signalDecorators");
+class ResponseExampleStorage {
+}
+const getPredefinedRequestExample = (modelRef) => {
+  return Reflect.getMetadata(modelRef, ResponseExampleStorage.prototype);
+};
+const getPredefinedResponseExample = (modelRef) => {
+  return Reflect.getMetadata(modelRef, ResponseExampleStorage.prototype);
+};
+const getResponseExample = (ref) => {
+  const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(ref);
+  const existing = getPredefinedRequestExample(modelRef);
+  if (existing)
+    return existing;
+  const isScalar = (0, import_base.isGqlScalar)(modelRef);
+  if (isScalar)
+    return (0, import_base.arraiedModel)((0, import_constant.getScalarExample)(modelRef), arrDepth);
+  const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
+  const example = {};
+  fieldMetas.forEach((fieldMeta) => {
+    if (fieldMeta.example)
+      example[fieldMeta.key] = fieldMeta.example;
+    else if (fieldMeta.enum)
+      example[fieldMeta.key] = (0, import_base.arraiedModel)(fieldMeta.enum.values[0], fieldMeta.arrDepth);
+    else
+      example[fieldMeta.key] = getResponseExample(fieldMeta.modelRef);
+  });
+  const result = (0, import_base.arraiedModel)(example, arrDepth);
+  Reflect.defineMetadata(ref, result, ResponseExampleStorage.prototype);
+  return result;
+};
+class RequestExampleStorage {
+}
+const getRequestExample = (ref) => {
+  const existing = getPredefinedRequestExample(ref);
+  if (existing)
+    return existing;
+  const fieldMetas = (0, import_constant.getFieldMetas)(ref);
+  const example = {};
+  const isScalar = (0, import_base.isGqlScalar)(ref);
+  if (isScalar)
+    return (0, import_constant.getScalarExample)(ref);
+  else {
+    fieldMetas.forEach((fieldMeta) => {
+      if (!fieldMeta.isScalar && fieldMeta.isClass)
+        example[fieldMeta.key] = "ObjectID";
+      else
+        example[fieldMeta.key] = fieldMeta.example ?? fieldMeta.enum ? (0, import_base.arraiedModel)(fieldMeta.example ?? (fieldMeta.enum?.values)[0], fieldMeta.optArrDepth) : (0, import_base.arraiedModel)(getRequestExample(fieldMeta.modelRef), fieldMeta.arrDepth);
+    });
+  }
+  Reflect.defineMetadata(ref, example, RequestExampleStorage.prototype);
+  return example;
+};
+const makeRequestExample = (sigRef, key) => {
+  const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, key);
+  return getExampleData(argMetas);
+};
+const getExampleData = (argMetas, signalType = "graphql") => Object.fromEntries(
+  argMetas.filter((argMeta) => argMeta.type !== "Upload").map((argMeta) => {
+    const [argRef, argArrDepth] = (0, import_base.getNonArrayModel)(argMeta.returns());
+    const example = argMeta.argsOption.example ?? getRequestExample(argRef);
+    return [
+      argMeta.name,
+      (0, import_base.arraiedModel)(
+        signalType === "restapi" && argRef.prototype === import_base.JSON.prototype ? JSON.stringify(example, null, 2) : example,
+        argArrDepth
+      )
+    ];
+  })
+);
+const makeResponseExample = (sigRef, key) => {
+  const gqlMeta = (0, import_signalDecorators.getGqlMeta)(sigRef, key);
+  const example = getResponseExample(gqlMeta.returns());
+  return example;
+};