@cendarsoss/pusher-js 8.4.11

package/dist/node/filter.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Filter = {
+  // Comparison operators
+  /**
+   * Creates an equality comparison: key == val
+   * @param key The tag key to compare
+   * @param val The value to compare against
+   * @returns FilterNode for equality comparison
+   */
+  eq: (key, val) => ({
+    key,
+    cmp: "eq",
+    val
+  }),
+  /**
+   * Creates an inequality comparison: key != val
+   * @param key The tag key to compare
+   * @param val The value to compare against
+   * @returns FilterNode for inequality comparison
+   */
+  neq: (key, val) => ({
+    key,
+    cmp: "neq",
+    val
+  }),
+  /**
+   * Creates a set membership comparison: key in [vals...]
+   * @param key The tag key to compare
+   * @param vals Array of values for set membership
+   * @returns FilterNode for set membership comparison
+   */
+  in: (key, vals) => ({
+    key,
+    cmp: "in",
+    vals
+  }),
+  /**
+   * Creates a set non-membership comparison: key not in [vals...]
+   * @param key The tag key to compare
+   * @param vals Array of values for set non-membership
+   * @returns FilterNode for set non-membership comparison
+   */
+  nin: (key, vals) => ({
+    key,
+    cmp: "nin",
+    vals
+  }),
+  /**
+   * Creates an existence check: key exists
+   * @param key The tag key to check for existence
+   * @returns FilterNode for existence check
+   */
+  exists: (key) => ({
+    key,
+    cmp: "ex"
+  }),
+  /**
+   * Creates a non-existence check: key does not exist
+   * @param key The tag key to check for non-existence
+   * @returns FilterNode for non-existence check
+   */
+  notExists: (key) => ({
+    key,
+    cmp: "nex"
+  }),
+  /**
+   * Creates a starts-with comparison: key starts with val
+   * @param key The tag key to compare
+   * @param val The prefix to match
+   * @returns FilterNode for starts-with comparison
+   */
+  startsWith: (key, val) => ({
+    key,
+    cmp: "sw",
+    val
+  }),
+  /**
+   * Creates an ends-with comparison: key ends with val
+   * @param key The tag key to compare
+   * @param val The suffix to match
+   * @returns FilterNode for ends-with comparison
+   */
+  endsWith: (key, val) => ({
+    key,
+    cmp: "ew",
+    val
+  }),
+  /**
+   * Creates a contains comparison: key contains val
+   * @param key The tag key to compare
+   * @param val The substring to match
+   * @returns FilterNode for contains comparison
+   */
+  contains: (key, val) => ({
+    key,
+    cmp: "ct",
+    val
+  }),
+  /**
+   * Creates a greater-than comparison: key > val (numeric)
+   * @param key The tag key to compare
+   * @param val The numeric value to compare against (as string)
+   * @returns FilterNode for greater-than comparison
+   */
+  gt: (key, val) => ({
+    key,
+    cmp: "gt",
+    val
+  }),
+  /**
+   * Creates a greater-than-or-equal comparison: key >= val (numeric)
+   * @param key The tag key to compare
+   * @param val The numeric value to compare against (as string)
+   * @returns FilterNode for greater-than-or-equal comparison
+   */
+  gte: (key, val) => ({
+    key,
+    cmp: "gte",
+    val
+  }),
+  /**
+   * Creates a less-than comparison: key < val (numeric)
+   * @param key The tag key to compare
+   * @param val The numeric value to compare against (as string)
+   * @returns FilterNode for less-than comparison
+   */
+  lt: (key, val) => ({
+    key,
+    cmp: "lt",
+    val
+  }),
+  /**
+   * Creates a less-than-or-equal comparison: key <= val (numeric)
+   * @param key The tag key to compare
+   * @param val The numeric value to compare against (as string)
+   * @returns FilterNode for less-than-or-equal comparison
+   */
+  lte: (key, val) => ({
+    key,
+    cmp: "lte",
+    val
+  }),
+  // Logical operators
+  /**
+   * Creates an AND logical operation: all children must match
+   * @param nodes Child filter nodes to combine with AND
+   * @returns FilterNode for AND operation
+   */
+  and: (...nodes) => ({
+    op: "and",
+    nodes
+  }),
+  /**
+   * Creates an OR logical operation: at least one child must match
+   * @param nodes Child filter nodes to combine with OR
+   * @returns FilterNode for OR operation
+   */
+  or: (...nodes) => ({
+    op: "or",
+    nodes
+  }),
+  /**
+   * Creates a NOT logical operation: negates the child
+   * @param node Child filter node to negate
+   * @returns FilterNode for NOT operation
+   */
+  not: (node) => ({
+    op: "not",
+    nodes: [node]
+  })
+};
+function validateFilter(filter) {
+  if (filter.op) {
+    const op = filter.op;
+    if (!["and", "or", "not"].includes(op)) {
+      return `Invalid logical operator: ${op}`;
+    }
+    if (!filter.nodes || !Array.isArray(filter.nodes)) {
+      return `Logical operation '${op}' requires nodes array`;
+    }
+    if (op === "not" && filter.nodes.length !== 1) {
+      return `NOT operation requires exactly one child node, got ${filter.nodes.length}`;
+    }
+    if ((op === "and" || op === "or") && filter.nodes.length === 0) {
+      return `${op.toUpperCase()} operation requires at least one child node`;
+    }
+    for (let i = 0; i < filter.nodes.length; i++) {
+      const childError = validateFilter(filter.nodes[i]);
+      if (childError) {
+        return `Child node ${i}: ${childError}`;
+      }
+    }
+  } else {
+    if (!filter.key) {
+      return "Leaf node requires a key";
+    }
+    if (!filter.cmp) {
+      return "Leaf node requires a comparison operator";
+    }
+    const validOps = ["eq", "neq", "in", "nin", "ex", "nex", "sw", "ew", "ct", "gt", "gte", "lt", "lte"];
+    if (!validOps.includes(filter.cmp)) {
+      return `Invalid comparison operator: ${filter.cmp}`;
+    }
+    if (filter.cmp === "in" || filter.cmp === "nin") {
+      if (!filter.vals || !Array.isArray(filter.vals) || filter.vals.length === 0) {
+        return `${filter.cmp} operation requires non-empty vals array`;
+      }
+    } else if (filter.cmp === "ex" || filter.cmp === "nex") ;
+    else {
+      if (!filter.val) {
+        return `${filter.cmp} operation requires a val`;
+      }
+    }
+  }
+  return null;
+}
+const FilterExamples = {
+  /**
+   * Filter for a specific event type
+   * @example Filter.eq("event_type", "goal")
+   */
+  eventType: (type) => Filter.eq("event_type", type),
+  /**
+   * Filter for events in a set of types
+   * @example FilterExamples.eventTypes(["goal", "shot"])
+   */
+  eventTypes: (types) => Filter.in("event_type", types),
+  /**
+   * Filter for numeric range
+   * @example FilterExamples.range("xG", "0.5", "0.9")
+   */
+  range: (key, min, max) => Filter.and(
+    Filter.gte(key, min),
+    Filter.lte(key, max)
+  ),
+  /**
+   * Filter for goals OR high-probability shots
+   * @example FilterExamples.importantEvents("0.8")
+   */
+  importantEvents: (xGThreshold) => Filter.or(
+    Filter.eq("event_type", "goal"),
+    Filter.and(
+      Filter.eq("event_type", "shot"),
+      Filter.gte("xG", xGThreshold)
+    )
+  )
+};
+exports.Filter = Filter;
+exports.FilterExamples = FilterExamples;
+exports.validateFilter = validateFilter;
+//# sourceMappingURL=filter.js.map

package/dist/node/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.js","sources":["../../src/core/channels/filter.ts"],"sourcesContent":["// sockudo-js/src/core/channels/filter.ts\n\n/**\n * Filter node structure for publication filtering by tags.\n *\n * This structure matches the server-side FilterNode format for zero-allocation\n * evaluation during message broadcast.\n */\nexport interface FilterNode {\n  /** Logical operator: \"and\", \"or\", \"not\" (if present, this is a branch node) */\n  op?: string;\n\n  /** Key for comparison (leaf nodes only) */\n  key?: string;\n\n  /** Comparison operator: \"eq\", \"neq\", \"in\", \"nin\", \"ex\", \"nex\", \"sw\", \"ew\", \"ct\", \"gt\", \"gte\", \"lt\", \"lte\" */\n  cmp?: string;\n\n  /** Single value for most comparisons */\n  val?: string;\n\n  /** Multiple values for set operations (in, nin) */\n  vals?: string[];\n\n  /** Child nodes for logical operations */\n  nodes?: FilterNode[];\n}\n\n/**\n * Builder for constructing filter nodes programmatically.\n *\n * Provides a clean API for creating complex filters without dealing with\n * the internal FilterNode structure directly.\n *\n * @example\n * ```typescript\n * // Simple equality filter\n * const filter = Filter.eq(\"event_type\", \"goal\");\n *\n * // Complex nested filter\n * const filter = Filter.or(\n *   Filter.eq(\"event_type\", \"goal\"),\n *   Filter.and(\n *     Filter.eq(\"event_type\", \"shot\"),\n *     Filter.gte(\"xG\", \"0.8\")\n *   )\n * );\n * ```\n */\nexport const Filter = {\n  // Comparison operators\n\n  /**\n   * Creates an equality comparison: key == val\n   * @param key The tag key to compare\n   * @param val The value to compare against\n   * @returns FilterNode for equality comparison\n   */\n  eq: (key: string, val: string): FilterNode => ({\n    key,\n    cmp: \"eq\",\n    val\n  }),\n\n  /**\n   * Creates an inequality comparison: key != val\n   * @param key The tag key to compare\n   * @param val The value to compare against\n   * @returns FilterNode for inequality comparison\n   */\n  neq: (key: string, val: string): FilterNode => ({\n    key,\n    cmp: \"neq\",\n    val\n  }),\n\n  /**\n   * Creates a set membership comparison: key in [vals...]\n   * @param key The tag key to compare\n   * @param vals Array of values for set membership\n   * @returns FilterNode for set membership comparison\n   */\n  in: (key: string, vals: string[]): FilterNode => ({\n    key,\n    cmp: \"in\",\n    vals\n  }),\n\n  /**\n   * Creates a set non-membership comparison: key not in [vals...]\n   * @param key The tag key to compare\n   * @param vals Array of values for set non-membership\n   * @returns FilterNode for set non-membership comparison\n   */\n  nin: (key: string, vals: string[]): FilterNode => ({\n    key,\n    cmp: \"nin\",\n    vals\n  }),\n\n  /**\n   * Creates an existence check: key exists\n   * @param key The tag key to check for existence\n   * @returns FilterNode for existence check\n   */\n  exists: (key: string): FilterNode => ({\n    key,\n    cmp: \"ex\"\n  }),\n\n  /**\n   * Creates a non-existence check: key does not exist\n   * @param key The tag key to check for non-existence\n   * @returns FilterNode for non-existence check\n   */\n  notExists: (key: string): FilterNode => ({\n    key,\n    cmp: \"nex\"\n  }),\n\n  /**\n   * Creates a starts-with comparison: key starts with val\n   * @param key The tag key to compare\n   * @param val The prefix to match\n   * @returns FilterNode for starts-with comparison\n   */\n  startsWith: (key: string, val: string): FilterNode => ({\n    key,\n    cmp: \"sw\",\n    val\n  }),\n\n  /**\n   * Creates an ends-with comparison: key ends with val\n   * @param key The tag key to compare\n   * @param val The suffix to match\n   * @returns FilterNode for ends-with comparison\n   */\n  endsWith: (key: string, val: string): FilterNode => ({\n    key,\n    cmp: \"ew\",\n    val\n  }),\n\n  /**\n   * Creates a contains comparison: key contains val\n   * @param key The tag key to compare\n   * @param val The substring to match\n   * @returns FilterNode for contains comparison\n   */\n  contains: (key: string, val: string): FilterNode => ({\n    key,\n    cmp: \"ct\",\n    val\n  }),\n\n  /**\n   * Creates a greater-than comparison: key > val (numeric)\n   * @param key The tag key to compare\n   * @param val The numeric value to compare against (as string)\n   * @returns FilterNode for greater-than comparison\n   */\n  gt: (key: string, val: string): FilterNode => ({\n    key,\n    cmp: \"gt\",\n    val\n  }),\n\n  /**\n   * Creates a greater-than-or-equal comparison: key >= val (numeric)\n   * @param key The tag key to compare\n   * @param val The numeric value to compare against (as string)\n   * @returns FilterNode for greater-than-or-equal comparison\n   */\n  gte: (key: string, val: string): FilterNode => ({\n    key,\n    cmp: \"gte\",\n    val\n  }),\n\n  /**\n   * Creates a less-than comparison: key < val (numeric)\n   * @param key The tag key to compare\n   * @param val The numeric value to compare against (as string)\n   * @returns FilterNode for less-than comparison\n   */\n  lt: (key: string, val: string): FilterNode => ({\n    key,\n    cmp: \"lt\",\n    val\n  }),\n\n  /**\n   * Creates a less-than-or-equal comparison: key <= val (numeric)\n   * @param key The tag key to compare\n   * @param val The numeric value to compare against (as string)\n   * @returns FilterNode for less-than-or-equal comparison\n   */\n  lte: (key: string, val: string): FilterNode => ({\n    key,\n    cmp: \"lte\",\n    val\n  }),\n\n  // Logical operators\n\n  /**\n   * Creates an AND logical operation: all children must match\n   * @param nodes Child filter nodes to combine with AND\n   * @returns FilterNode for AND operation\n   */\n  and: (...nodes: FilterNode[]): FilterNode => ({\n    op: \"and\",\n    nodes\n  }),\n\n  /**\n   * Creates an OR logical operation: at least one child must match\n   * @param nodes Child filter nodes to combine with OR\n   * @returns FilterNode for OR operation\n   */\n  or: (...nodes: FilterNode[]): FilterNode => ({\n    op: \"or\",\n    nodes\n  }),\n\n  /**\n   * Creates a NOT logical operation: negates the child\n   * @param node Child filter node to negate\n   * @returns FilterNode for NOT operation\n   */\n  not: (node: FilterNode): FilterNode => ({\n    op: \"not\",\n    nodes: [node]\n  })\n};\n\n/**\n * Validates a filter node structure.\n *\n * @param filter The filter node to validate\n * @returns Error message if invalid, null if valid\n */\nexport function validateFilter(filter: FilterNode): string | null {\n  if (filter.op) {\n    // Branch node - logical operation\n    const op = filter.op;\n\n    if (![\"and\", \"or\", \"not\"].includes(op)) {\n      return `Invalid logical operator: ${op}`;\n    }\n\n    if (!filter.nodes || !Array.isArray(filter.nodes)) {\n      return `Logical operation '${op}' requires nodes array`;\n    }\n\n    if (op === \"not\" && filter.nodes.length !== 1) {\n      return `NOT operation requires exactly one child node, got ${filter.nodes.length}`;\n    }\n\n    if ((op === \"and\" || op === \"or\") && filter.nodes.length === 0) {\n      return `${op.toUpperCase()} operation requires at least one child node`;\n    }\n\n    // Validate all children recursively\n    for (let i = 0; i < filter.nodes.length; i++) {\n      const childError = validateFilter(filter.nodes[i]);\n      if (childError) {\n        return `Child node ${i}: ${childError}`;\n      }\n    }\n  } else {\n    // Leaf node - comparison\n    if (!filter.key) {\n      return \"Leaf node requires a key\";\n    }\n\n    if (!filter.cmp) {\n      return \"Leaf node requires a comparison operator\";\n    }\n\n    const validOps = [\"eq\", \"neq\", \"in\", \"nin\", \"ex\", \"nex\", \"sw\", \"ew\", \"ct\", \"gt\", \"gte\", \"lt\", \"lte\"];\n    if (!validOps.includes(filter.cmp)) {\n      return `Invalid comparison operator: ${filter.cmp}`;\n    }\n\n    // Check value requirements based on operator\n    if (filter.cmp === \"in\" || filter.cmp === \"nin\") {\n      if (!filter.vals || !Array.isArray(filter.vals) || filter.vals.length === 0) {\n        return `${filter.cmp} operation requires non-empty vals array`;\n      }\n    } else if (filter.cmp === \"ex\" || filter.cmp === \"nex\") {\n      // Existence checks don't need values\n    } else {\n      if (!filter.val) {\n        return `${filter.cmp} operation requires a val`;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Example filter patterns for common use cases\n */\nexport const FilterExamples = {\n  /**\n   * Filter for a specific event type\n   * @example Filter.eq(\"event_type\", \"goal\")\n   */\n  eventType: (type: string) => Filter.eq(\"event_type\", type),\n\n  /**\n   * Filter for events in a set of types\n   * @example FilterExamples.eventTypes([\"goal\", \"shot\"])\n   */\n  eventTypes: (types: string[]) => Filter.in(\"event_type\", types),\n\n  /**\n   * Filter for numeric range\n   * @example FilterExamples.range(\"xG\", \"0.5\", \"0.9\")\n   */\n  range: (key: string, min: string, max: string) =>\n    Filter.and(\n      Filter.gte(key, min),\n      Filter.lte(key, max)\n    ),\n\n  /**\n   * Filter for goals OR high-probability shots\n   * @example FilterExamples.importantEvents(\"0.8\")\n   */\n  importantEvents: (xGThreshold: string) =>\n    Filter.or(\n      Filter.eq(\"event_type\", \"goal\"),\n      Filter.and(\n        Filter.eq(\"event_type\", \"shot\"),\n        Filter.gte(\"xG\", xGThreshold)\n      )\n    )\n};\n"],"names":[],"mappings":"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"}