@cendarsoss/pusher-js 8.4.13 → 8.4.14

package/dist/web/filter.mjs

@@ -1,168 +1,75 @@
 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]
@@ -214,35 +121,10 @@ function validateFilter(filter) {
   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)
-    )
-  )
+  range: (key, min, max) => Filter.and(Filter.gte(key, min), Filter.lte(key, max)),
+  importantEvents: (xGThreshold) => Filter.or(Filter.eq("event_type", "goal"), Filter.and(Filter.eq("event_type", "shot"), Filter.gte("xG", xGThreshold)))
 };
 export {
   Filter,

package/dist/web/filter.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"filter.mjs","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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"}
+{"version":3,"file":"filter.mjs","sources":["../../src/core/channels/filter.js"],"sourcesContent":["export const Filter = {\n    eq: (key, val) => ({\n        key,\n        cmp: \"eq\",\n        val\n    }),\n    neq: (key, val) => ({\n        key,\n        cmp: \"neq\",\n        val\n    }),\n    in: (key, vals) => ({\n        key,\n        cmp: \"in\",\n        vals\n    }),\n    nin: (key, vals) => ({\n        key,\n        cmp: \"nin\",\n        vals\n    }),\n    exists: (key) => ({\n        key,\n        cmp: \"ex\"\n    }),\n    notExists: (key) => ({\n        key,\n        cmp: \"nex\"\n    }),\n    startsWith: (key, val) => ({\n        key,\n        cmp: \"sw\",\n        val\n    }),\n    endsWith: (key, val) => ({\n        key,\n        cmp: \"ew\",\n        val\n    }),\n    contains: (key, val) => ({\n        key,\n        cmp: \"ct\",\n        val\n    }),\n    gt: (key, val) => ({\n        key,\n        cmp: \"gt\",\n        val\n    }),\n    gte: (key, val) => ({\n        key,\n        cmp: \"gte\",\n        val\n    }),\n    lt: (key, val) => ({\n        key,\n        cmp: \"lt\",\n        val\n    }),\n    lte: (key, val) => ({\n        key,\n        cmp: \"lte\",\n        val\n    }),\n    and: (...nodes) => ({\n        op: \"and\",\n        nodes\n    }),\n    or: (...nodes) => ({\n        op: \"or\",\n        nodes\n    }),\n    not: (node) => ({\n        op: \"not\",\n        nodes: [node]\n    })\n};\nexport function validateFilter(filter) {\n    if (filter.op) {\n        const op = filter.op;\n        if (![\"and\", \"or\", \"not\"].includes(op)) {\n            return `Invalid logical operator: ${op}`;\n        }\n        if (!filter.nodes || !Array.isArray(filter.nodes)) {\n            return `Logical operation '${op}' requires nodes array`;\n        }\n        if (op === \"not\" && filter.nodes.length !== 1) {\n            return `NOT operation requires exactly one child node, got ${filter.nodes.length}`;\n        }\n        if ((op === \"and\" || op === \"or\") && filter.nodes.length === 0) {\n            return `${op.toUpperCase()} operation requires at least one child node`;\n        }\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    }\n    else {\n        if (!filter.key) {\n            return \"Leaf node requires a key\";\n        }\n        if (!filter.cmp) {\n            return \"Leaf node requires a comparison operator\";\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        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        }\n        else if (filter.cmp === \"ex\" || filter.cmp === \"nex\") {\n        }\n        else {\n            if (!filter.val) {\n                return `${filter.cmp} operation requires a val`;\n            }\n        }\n    }\n    return null;\n}\nexport const FilterExamples = {\n    eventType: (type) => Filter.eq(\"event_type\", type),\n    eventTypes: (types) => Filter.in(\"event_type\", types),\n    range: (key, min, max) => Filter.and(Filter.gte(key, min), Filter.lte(key, max)),\n    importantEvents: (xGThreshold) => Filter.or(Filter.eq(\"event_type\", \"goal\"), Filter.and(Filter.eq(\"event_type\", \"shot\"), Filter.gte(\"xG\", xGThreshold)))\n};\n//# sourceMappingURL=filter.js.map"],"names":[],"mappings":"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"}