@statsig/js-on-device-eval-client 0.0.1-beta.10

package/.eslintrc.json

@@ -0,0 +1,34 @@
+{
+  "extends": ["../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/dependency-checks": [
+          "error",
+          {
+            "ignoredDependencies": [
+              "jest-fetch-mock",
+              "@nx/webpack",
+              "statsig-test-helpers"
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}

package/README.md

@@ -0,0 +1,12 @@
+# Statsig - On Device Evaluations
+
+> [!IMPORTANT]
+> This version of the SDK is still in beta. The non-beta version can be found [here](https://github.com/statsig-io/js-local-eval).
+
+The JavaScript SDK for single user client environments. If you need a SDK for another language or server environment, check out our [other SDKs](https://docs.statsig.com/#sdks).
+
+Statsig helps you move faster with feature gates (feature flags), and/or dynamic configs. It also allows you to run A/B/n tests to validate your new features and understand their impact on your KPIs. If you're new to Statsig, check out our product and create an account at [statsig.com](https://www.statsig.com).
+
+## Getting Started
+
+Check out our [SDK docs](https://docs.statsig.com/client/javascript-sdk) to get started.

package/jest.config.ts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+export default {
+  displayName: 'js-on-device-eval-client',
+  preset: '../../jest.preset.js',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/packages/js-on-device-eval-client',
+};

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@statsig/js-on-device-eval-client",
+  "version": "0.0.1-beta.10",
+  "dependencies": {
+    "@statsig/client-core": "0.0.1-beta.10",
+    "@statsig/sha256": "0.0.1-beta.10"
+  },
+  "jsdelivr": "./build/js-on-device-eval-client.min.js",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts"
+}

package/project.json

@@ -0,0 +1,52 @@
+{
+  "name": "js-on-device-eval-client",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/js-on-device-eval-client/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "command": ":",
+      "dependsOn": ["^build", "build-webpack"]
+    },
+    "build-ts": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/packages/js-on-device-eval-client",
+        "main": "packages/js-on-device-eval-client/src/index.ts",
+        "tsConfig": "packages/js-on-device-eval-client/tsconfig.lib.json",
+        "assets": ["packages/js-on-device-eval-client/*.md"]
+      }
+    },
+    "publish": {
+      "command": "ts-node ./tools/scripts/publish.ts js-on-device-eval-client",
+      "dependsOn": ["build"]
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"]
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "packages/js-on-device-eval-client/jest.config.ts"
+      }
+    },
+    "build-webpack": {
+      "executor": "@nx/webpack:webpack",
+      "outputs": ["{options.outputPath}"],
+      "defaultConfiguration": "production",
+      "options": {
+        "statsJson": true,
+        "verbose": true,
+        "outputPath": "overridden in webpack config",
+        "main": "overridden in webpack config",
+        "tsConfig": "packages/js-on-device-eval-client/tsconfig.lib.json",
+        "webpackConfig": "packages/js-on-device-eval-client/webpack.config.js"
+      },
+      "dependsOn": ["build-ts"]
+    }
+  },
+  "tags": []
+}

package/src/Errors.ts

@@ -0,0 +1,6 @@
+export class StatsigUnsupportedEvaluationError extends Error {
+  constructor(condition?: string) {
+    super(`Unsupported condition or operator: ${condition}`);
+    Object.setPrototypeOf(this, StatsigUnsupportedEvaluationError.prototype);
+  }
+}

package/src/EvaluationComparison.ts

@@ -0,0 +1,189 @@
+export default {
+  compareNumbers(left: unknown, right: unknown, operator: string): boolean {
+    if (left == null || right == null) {
+      return false;
+    }
+
+    const numA = Number(left);
+    const numB = Number(right);
+    if (isNaN(numA) || isNaN(numB)) {
+      return false;
+    }
+
+    switch (operator) {
+      case 'gt':
+        return left > right;
+      case 'gte':
+        return left >= right;
+      case 'lt':
+        return left < right;
+      case 'lte':
+        return left <= right;
+      default:
+        return false;
+    }
+  },
+
+  compareVersions(left: unknown, right: unknown, operator: string): boolean {
+    if (left == null || right == null) {
+      return false;
+    }
+
+    let leftStr = String(left);
+    let rightStr = String(right);
+
+    const removeSuffix = (str: string): string => {
+      const index = str.indexOf('-');
+      return index !== -1 ? str.substring(0, index) : str;
+    };
+
+    leftStr = removeSuffix(leftStr);
+    rightStr = removeSuffix(rightStr);
+
+    const comparison = (leftStr: string, rightStr: string): number => {
+      const leftParts = leftStr.split('.').map((part) => parseInt(part));
+      const rightParts = rightStr.split('.').map((part) => parseInt(part));
+
+      let i = 0;
+      while (i < Math.max(leftParts.length, rightParts.length)) {
+        const leftCount = i < leftParts.length ? leftParts[i] : 0;
+        const rightCount = i < rightParts.length ? rightParts[i] : 0;
+
+        if (leftCount < rightCount) {
+          return -1;
+        }
+
+        if (leftCount > rightCount) {
+          return 1;
+        }
+
+        i++;
+      }
+      return 0;
+    };
+
+    const result = comparison(leftStr, rightStr);
+    switch (operator) {
+      case 'version_gt':
+        return result > 0;
+      case 'version_gte':
+        return result >= 0;
+      case 'version_lt':
+        return result < 0;
+      case 'version_lte':
+        return result <= 0;
+      case 'version_eq':
+        return result === 0;
+      case 'version_neq':
+        return result !== 0;
+      default:
+        return false;
+    }
+  },
+
+  compareStringInArray(
+    value: unknown,
+    array: unknown,
+    operator: string,
+  ): boolean {
+    if (!Array.isArray(array)) {
+      return false;
+    }
+
+    const ignoreCase =
+      operator !== 'any_case_sensitive' && operator !== 'none_case_sensitive';
+
+    const result =
+      array.findIndex((current) => {
+        const valueString = String(value);
+        const currentString = String(current);
+
+        const left = ignoreCase ? valueString.toLowerCase() : valueString;
+        const right = ignoreCase ? currentString.toLowerCase() : currentString;
+
+        switch (operator) {
+          case 'any':
+          case 'none':
+          case 'any_case_sensitive':
+          case 'none_case_sensitive':
+            return left === right;
+          case 'str_starts_with_any':
+            return left.startsWith(right);
+          case 'str_ends_with_any':
+            return left.endsWith(right);
+          case 'str_contains_any':
+          case 'str_contains_none':
+            return left.includes(right);
+          default:
+            return false;
+        }
+      }) !== -1;
+
+    switch (operator) {
+      case 'none':
+      case 'none_case_sensitive':
+      case 'str_contains_none':
+        return !result;
+      default:
+        return result;
+    }
+  },
+
+  compareStringWithRegEx(value: unknown, target: unknown): boolean {
+    try {
+      const valueString = String(value);
+      if (valueString.length < 1000) {
+        return new RegExp(String(target)).test(valueString);
+      }
+    } catch (e) {
+      // noop
+    }
+
+    return false;
+  },
+
+  compareTime(left: unknown, right: unknown, operator: string): boolean {
+    if (left == null || right == null) {
+      return false;
+    }
+
+    try {
+      // Try to parse into date as a string first, if not, try unixtime
+      let dateLeft = new Date(String(left));
+      if (isNaN(dateLeft.getTime())) {
+        dateLeft = new Date(Number(left));
+      }
+
+      let dateRight = new Date(String(right));
+      if (isNaN(dateRight.getTime())) {
+        dateRight = new Date(Number(right));
+      }
+
+      const timeLeft = dateLeft.getTime();
+      const timeRight = dateRight.getTime();
+
+      if (isNaN(timeLeft) || isNaN(timeRight)) {
+        return false;
+      }
+
+      switch (operator) {
+        case 'before':
+          return timeLeft < timeRight;
+        case 'after':
+          return timeLeft > timeRight;
+        case 'on':
+          return _startOfDay(dateLeft) === _startOfDay(dateRight);
+        default:
+          return false;
+      }
+    } catch (e) {
+      // malformatted input, returning false
+      return false;
+    }
+  },
+};
+
+function _startOfDay(date: Date): number {
+  date.setUTCHours(0, 0, 0, 0);
+  return date.getTime();
+}

package/src/EvaluationResult.ts

@@ -0,0 +1,92 @@
+import {
+  DynamicConfigEvaluation,
+  GateEvaluation,
+  LayerEvaluation,
+  SecondaryExposure,
+} from '@statsig/client-core';
+
+import { Spec } from './SpecStore';
+
+export type EvaluationResult = {
+  readonly unsupported: boolean;
+  readonly bool_value: boolean;
+  readonly rule_id: string;
+  readonly secondary_exposures: SecondaryExposure[];
+  readonly json_value: Record<string, unknown>;
+  readonly explicit_parameters: string[] | null;
+  readonly allocated_experiment_name: string | null;
+  readonly undelegated_secondary_exposures: SecondaryExposure[] | undefined;
+  readonly is_experiment_group: boolean;
+  readonly group_name: string | null;
+};
+
+export function makeEvalResult(
+  overrides: Partial<EvaluationResult>,
+): EvaluationResult {
+  const base: EvaluationResult = {
+    unsupported: false,
+    bool_value: false,
+    rule_id: '',
+    secondary_exposures: [],
+    json_value: {},
+    explicit_parameters: null,
+    allocated_experiment_name: null,
+    is_experiment_group: false,
+    group_name: null,
+    undelegated_secondary_exposures: undefined,
+  };
+
+  return { ...base, ...overrides };
+}
+
+export function resultToGateEval(
+  spec: Spec,
+  result: EvaluationResult,
+): GateEvaluation {
+  return {
+    name: spec.name,
+    id_type: spec.idType,
+    rule_id: result.rule_id,
+    value: result.bool_value,
+    secondary_exposures: result.secondary_exposures,
+  };
+}
+
+export function resultToConfigEval(
+  spec: Spec,
+  result: EvaluationResult,
+): DynamicConfigEvaluation {
+  return {
+    name: spec.name,
+    id_type: spec.idType,
+    rule_id: result.rule_id,
+    value: result.json_value,
+    secondary_exposures: result.secondary_exposures,
+    group: result.group_name ?? '',
+    group_name: result.group_name ?? undefined,
+    is_device_based: false,
+    is_experiment_active: spec.isActive,
+    is_user_in_experiment: result.is_experiment_group,
+  };
+}
+
+export function resultToLayerEval(
+  layerSpec: Spec,
+  experimentSpec: Spec | null,
+  result: EvaluationResult,
+): LayerEvaluation {
+  return {
+    name: layerSpec.name,
+    rule_id: result.rule_id,
+    value: result.json_value,
+    secondary_exposures: result.secondary_exposures,
+    undelegated_secondary_exposures: result.undelegated_secondary_exposures,
+    allocated_experiment_name: result.allocated_experiment_name ?? '',
+    explicit_parameters: result.explicit_parameters ?? [],
+    group: result.group_name ?? '',
+    group_name: result.group_name ?? undefined,
+    is_device_based: false,
+    is_experiment_active: experimentSpec?.isActive,
+    is_user_in_experiment: result.is_experiment_group,
+  };
+}