@vercel/flags-core 0.1.8 → 1.0.0

package/dist/chunk-4IFGPGNY.js

@@ -1,566 +0,0 @@
-// src/index.ts
-import { createClient as createEdgeConfigClient } from "@vercel/edge-config";
-
-// src/evaluate.ts
-import { xxHash32 as hashInput } from "js-xxhash";
-
-// src/types.ts
-var ResolutionReason = /* @__PURE__ */ ((ResolutionReason2) => {
-  ResolutionReason2["PAUSED"] = "paused";
-  ResolutionReason2["TARGET_MATCH"] = "target_match";
-  ResolutionReason2["RULE_MATCH"] = "rule_match";
-  ResolutionReason2["FALLTHROUGH"] = "fallthrough";
-  ResolutionReason2["ERROR"] = "error";
-  return ResolutionReason2;
-})(ResolutionReason || {});
-var Original;
-((Original2) => {
-  let AccessorType;
-  ((AccessorType2) => {
-    AccessorType2["SEGMENT"] = "segment";
-    AccessorType2["ENTITY"] = "entity";
-  })(AccessorType = Original2.AccessorType || (Original2.AccessorType = {}));
-})(Original || (Original = {}));
-var Packed;
-((Packed2) => {
-  let AccessorType;
-  ((AccessorType2) => {
-    AccessorType2["SEGMENT"] = "segment";
-    AccessorType2["ENTITY"] = "entity";
-  })(AccessorType = Packed2.AccessorType || (Packed2.AccessorType = {}));
-})(Packed || (Packed = {}));
-
-// src/utils.ts
-function exhaustivenessCheck(_) {
-  throw new Error("Exhaustiveness check failed");
-}
-
-// src/evaluate.ts
-function getProperty(obj, pathArray) {
-  return pathArray.reduce((acc, key) => {
-    if (acc && key in acc) {
-      return acc[key];
-    }
-    return void 0;
-  }, obj);
-}
-function access(lhs, params) {
-  if (Array.isArray(lhs))
-    return getProperty(params.entities, lhs);
-  if (lhs === Packed.AccessorType.SEGMENT)
-    throw new Error("Unexpected segment");
-  throw new Error("Accessor not implemented");
-}
-function isString(input) {
-  return typeof input === "string";
-}
-function isNumber(input) {
-  return typeof input === "number";
-}
-function isArray(input) {
-  return Array.isArray(input);
-}
-function matchTargetList(targets, params) {
-  for (const [kind, attributes] of Object.entries(targets)) {
-    for (const [attribute, values] of Object.entries(attributes)) {
-      const entity = access([kind, attribute], params);
-      if (isString(entity) && values.includes(entity))
-        return true;
-    }
-  }
-  return false;
-}
-function matchSegment(segment, params) {
-  var _a;
-  if (segment.include && matchTargetList(segment.include, params))
-    return true;
-  if (segment.exclude && matchTargetList(segment.exclude, params))
-    return false;
-  if (!((_a = segment.rules) == null ? void 0 : _a.length))
-    return false;
-  const firstMatchingRule = segment.rules.find(
-    (rule) => matchConditions(rule.conditions, params)
-  );
-  if (!firstMatchingRule)
-    return false;
-  return handleSegmentOutcome(params, firstMatchingRule.outcome);
-}
-function matchSegmentCondition(cmp, rhs, params) {
-  var _a, _b;
-  switch (cmp) {
-    case "eq" /* EQ */: {
-      const segment = (_a = params.segments) == null ? void 0 : _a[rhs];
-      if (!segment)
-        return false;
-      return matchSegment(segment, params);
-    }
-    case "!eq" /* NOT_EQ */: {
-      const segment = (_b = params.segments) == null ? void 0 : _b[rhs];
-      if (!segment)
-        return false;
-      return !matchSegment(segment, params);
-    }
-    case "oneOf" /* ONE_OF */: {
-      if (!isArray(rhs))
-        return false;
-      const segmentIds = rhs;
-      return segmentIds.some((segmentId) => {
-        var _a2;
-        const segment = (_a2 = params.segments) == null ? void 0 : _a2[segmentId];
-        if (!segment)
-          return false;
-        return matchSegment(segment, params);
-      });
-    }
-    case "!oneOf" /* NOT_ONE_OF */: {
-      const segmentIds = rhs;
-      return segmentIds.every((segmentId) => {
-        var _a2;
-        const segment = (_a2 = params.segments) == null ? void 0 : _a2[segmentId];
-        if (!segment)
-          return false;
-        return matchSegment(segment, params);
-      });
-    }
-    default:
-      throw new Error(`Comparator ${cmp} not implemented for segment`);
-  }
-}
-function matchConditions(conditions, params) {
-  return conditions.every((condition) => {
-    const [lhsAccessor, cmpKey, rhs] = condition;
-    if (lhsAccessor === Packed.AccessorType.SEGMENT) {
-      return rhs && matchSegmentCondition(cmpKey, rhs, params);
-    }
-    const lhs = access(lhsAccessor, params);
-    try {
-      switch (cmpKey) {
-        case "eq" /* EQ */:
-          return lhs === rhs;
-        case "!eq" /* NOT_EQ */:
-          return lhs !== rhs;
-        case "oneOf" /* ONE_OF */:
-          return isArray(rhs) && rhs.includes(lhs);
-        case "!oneOf" /* NOT_ONE_OF */:
-          return isArray(rhs) && typeof lhs !== "undefined" && !rhs.includes(lhs);
-        case "containsAllOf" /* CONTAINS_ALL_OF */: {
-          if (!Array.isArray(rhs) || !Array.isArray(lhs))
-            return false;
-          const lhsSet = new Set(lhs.filter(isString));
-          if (lhsSet.size === lhs.length) {
-            return rhs.filter(isString).every((item) => lhsSet.has(item));
-          }
-          return rhs.every((item) => lhs.includes(item));
-        }
-        case "containsAnyOf" /* CONTAINS_ANY_OF */: {
-          if (!Array.isArray(rhs) || !Array.isArray(lhs))
-            return false;
-          const rhsSet = new Set(rhs.filter(isString));
-          return lhs.some(
-            rhsSet.size === rhs.length ? (
-              // try to use a set if the rhs is a list of strings - O(1)
-              (item) => rhsSet.has(item)
-            ) : (
-              // otherwise we need to iterate over the values - O(n)
-              (item) => rhs.includes(item)
-            )
-          );
-        }
-        case "containsNoneOf" /* CONTAINS_NONE_OF */: {
-          if (!Array.isArray(rhs))
-            return false;
-          if (!Array.isArray(lhs))
-            return true;
-          const rhsSet = new Set(rhs.filter(isString));
-          return lhs.every(
-            rhsSet.size === rhs.length ? (
-              // try to use a set if the rhs is a list of strings - O(1)
-              (item) => !rhsSet.has(item)
-            ) : (
-              // otherwise we need to iterate over the values - O(n)
-              (item) => !rhs.includes(item)
-            )
-          );
-        }
-        case "startsWith" /* STARTS_WITH */:
-          return isString(lhs) && isString(rhs) && lhs.startsWith(rhs);
-        case "!startsWith" /* NOT_STARTS_WITH */:
-          return isString(lhs) && isString(rhs) && !lhs.startsWith(rhs);
-        case "endsWith" /* ENDS_WITH */:
-          return isString(lhs) && isString(rhs) && lhs.endsWith(rhs);
-        case "!endsWith" /* NOT_ENDS_WITH */:
-          return isString(lhs) && isString(rhs) && !lhs.endsWith(rhs);
-        case "ex" /* EXISTS */:
-          return lhs !== void 0 && lhs !== null;
-        case "!ex" /* NOT_EXISTS */:
-          return lhs === void 0 || lhs === null;
-        case "gt" /* GT */:
-          if (lhs === null || lhs === void 0)
-            return false;
-          return (isNumber(rhs) || isString(rhs)) && lhs > rhs;
-        case "gte" /* GTE */:
-          if (lhs === null || lhs === void 0)
-            return false;
-          return (isNumber(rhs) || isString(rhs)) && lhs >= rhs;
-        case "lt" /* LT */:
-          if (lhs === null || lhs === void 0)
-            return false;
-          return (isNumber(rhs) || isString(rhs)) && lhs < rhs;
-        case "lte" /* LTE */:
-          if (lhs === null || lhs === void 0)
-            return false;
-          return (isNumber(rhs) || isString(rhs)) && lhs <= rhs;
-        case "regex" /* REGEX */:
-          if (isString(lhs) && typeof rhs === "object" && !Array.isArray(rhs) && (rhs == null ? void 0 : rhs.type) === "regex") {
-            return new RegExp(rhs.pattern, rhs.flags).test(lhs);
-          }
-          return false;
-        case "!regex" /* NOT_REGEX */:
-          if (isString(lhs) && typeof rhs === "object" && !Array.isArray(rhs) && (rhs == null ? void 0 : rhs.type) === "regex") {
-            return !new RegExp(rhs.pattern, rhs.flags).test(lhs);
-          }
-          return false;
-        case "before" /* BEFORE */: {
-          if (!isString(lhs) || !isString(rhs))
-            return false;
-          const a = new Date(lhs);
-          const b = new Date(rhs);
-          return a.getTime() < b.getTime();
-        }
-        case "after" /* AFTER */: {
-          if (!isString(lhs) || !isString(rhs))
-            return false;
-          const a = new Date(lhs);
-          const b = new Date(rhs);
-          return a.getTime() > b.getTime();
-        }
-        default: {
-          const _x = cmpKey;
-          return false;
-        }
-      }
-    } catch (error) {
-      console.error("flags: Error matching conditions", error);
-      return false;
-    }
-  });
-}
-function sum(list) {
-  return list.reduce((acc, n) => acc + n, 0);
-}
-function handleSegmentOutcome(params, outcome) {
-  if (outcome === 1)
-    return true;
-  switch (outcome.type) {
-    case "split": {
-      const lhs = access(outcome.base, params);
-      if (typeof lhs !== "string")
-        return false;
-      const maxValue = 1e5;
-      if (outcome.passPromille <= 0)
-        return false;
-      if (outcome.passPromille >= maxValue)
-        return true;
-      const value = hashInput(lhs, params.definition.seed) % maxValue;
-      return value < outcome.passPromille;
-    }
-    default: {
-      const { type } = outcome;
-      exhaustivenessCheck(type);
-    }
-  }
-}
-function handleOutcome(params, outcome) {
-  if (typeof outcome === "number") {
-    return {
-      value: params.definition.variants[outcome],
-      outcomeType: "value" /* VALUE */
-    };
-  }
-  switch (outcome.type) {
-    case "split": {
-      const lhs = access(outcome.base, params);
-      const defaultOutcome = params.definition.variants[outcome.defaultVariant];
-      if (typeof lhs !== "string") {
-        return { value: defaultOutcome, outcomeType: "split" /* SPLIT */ };
-      }
-      const maxValue = 4294967295;
-      const value = hashInput(lhs, params.definition.seed);
-      const sumOfWeights = sum(outcome.weights);
-      const scaledWeights = outcome.weights.map(
-        (weight) => weight / sumOfWeights * maxValue
-      );
-      const variantIndex = findWeightedIndex(scaledWeights, value, maxValue);
-      return {
-        value: variantIndex === -1 ? defaultOutcome : params.definition.variants[variantIndex],
-        outcomeType: "split" /* SPLIT */
-      };
-    }
-    default: {
-      const { type } = outcome;
-      exhaustivenessCheck(type);
-    }
-  }
-}
-function evaluate(params) {
-  const envConfig = params.definition.environments[params.environment];
-  if (typeof envConfig === "number") {
-    return {
-      ...handleOutcome(params, envConfig),
-      reason: "paused" /* PAUSED */
-    };
-  }
-  if (!envConfig) {
-    return {
-      reason: "error" /* ERROR */,
-      errorMessage: `Could not find envConfig for "${params.environment}"`,
-      value: params.defaultValue
-    };
-  }
-  if ("reuse" in envConfig) {
-    const reuseEnvConfig = params.definition.environments[envConfig.reuse];
-    if (reuseEnvConfig === void 0) {
-      throw new Error(
-        `Could not find envConfig for "${envConfig.reuse}" when reusing`
-      );
-    }
-    return evaluate({ ...params, environment: envConfig.reuse });
-  }
-  if (envConfig.targets) {
-    const matchedIndex = envConfig.targets.findIndex(
-      (targetList) => matchTargetList(targetList, params)
-    );
-    if (matchedIndex > -1) {
-      return {
-        ...handleOutcome(params, matchedIndex),
-        reason: "target_match" /* TARGET_MATCH */
-      };
-    }
-  }
-  const firstMatchingRule = envConfig.rules ? envConfig.rules.find((rule) => matchConditions(rule.conditions, params)) : void 0;
-  if (firstMatchingRule) {
-    return {
-      ...handleOutcome(params, firstMatchingRule.outcome),
-      reason: "rule_match" /* RULE_MATCH */
-    };
-  }
-  return {
-    ...handleOutcome(params, envConfig.fallthrough),
-    reason: "fallthrough" /* FALLTHROUGH */
-  };
-}
-function findWeightedIndex(weights, value, maxValue) {
-  if (value < 0 || value >= maxValue)
-    return -1;
-  let sum2 = 0;
-  for (let i = 0; i < weights.length; i++) {
-    sum2 += weights[i];
-    if (value < sum2)
-      return i;
-  }
-  return -1;
-}
-
-// package.json
-var version = "0.1.8";
-
-// src/lib/report-value.ts
-function internalReportValue(key, value, data) {
-  var _a, _b;
-  const symbol = Symbol.for("@vercel/request-context");
-  const ctx = (_a = Reflect.get(globalThis, symbol)) == null ? void 0 : _a.get();
-  (_b = ctx == null ? void 0 : ctx.flags) == null ? void 0 : _b.reportValue(key, value, {
-    sdkVersion: version,
-    ...data
-  });
-}
-
-// src/client.ts
-function createClient({
-  environment,
-  dataSource
-}) {
-  return {
-    dataSource,
-    environment,
-    initialize: () => {
-      if (dataSource && typeof dataSource.initialize === "function") {
-        return dataSource.initialize();
-      }
-    },
-    shutdown: () => {
-      if (dataSource && typeof dataSource.shutdown === "function") {
-        return dataSource.shutdown();
-      }
-    },
-    async evaluate(flagKey, defaultValue, entities) {
-      const data = await dataSource.getData();
-      const flagDefinition = data.definitions[flagKey];
-      if (flagDefinition === void 0) {
-        return {
-          value: defaultValue,
-          reason: "error" /* ERROR */,
-          errorCode: "FLAG_NOT_FOUND" /* FLAG_NOT_FOUND */,
-          errorMessage: `Definition not found for flag "${flagKey}"`
-        };
-      }
-      const result = evaluate({
-        defaultValue,
-        definition: flagDefinition,
-        environment: this.environment,
-        entities: entities ?? {},
-        segments: data.segments
-      });
-      if (dataSource.projectId) {
-        internalReportValue(flagKey, result.value, {
-          originProjectId: dataSource.projectId,
-          originProvider: "vercel",
-          reason: result.reason,
-          outcomeType: result.reason !== "error" /* ERROR */ ? result.outcomeType : void 0
-        });
-      }
-      return result;
-    }
-  };
-}
-
-// src/store.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var store = new AsyncLocalStorage();
-
-// src/data-source/edge-config-data-source.ts
-var EdgeConfigDataSource = class {
-  connectionString;
-  edgeConfigClient;
-  edgeConfigItemKey;
-  requestCache;
-  projectId;
-  constructor(options) {
-    this.edgeConfigClient = options.edgeConfigClient;
-    this.edgeConfigItemKey = options.edgeConfigItemKey;
-    this.requestCache = /* @__PURE__ */ new WeakMap();
-    this.projectId = options.projectId;
-  }
-  // This is a temporary solution to avoid reading the Edge Config for every flag,
-  // and instead reading it once per request.
-  async getCachedData() {
-    const cacheKey = store.getStore();
-    if (cacheKey) {
-      const cached = this.requestCache.get(cacheKey);
-      if (cached) {
-        return cached;
-      }
-    }
-    const promise = this.edgeConfigClient.get(
-      this.edgeConfigItemKey
-    );
-    if (cacheKey)
-      this.requestCache.set(cacheKey, promise);
-    return promise;
-  }
-  async getData() {
-    const data = await this.getCachedData();
-    if (!data) {
-      throw new Error(
-        `No definitions found in Edge Config under key "${this.edgeConfigItemKey}"`
-      );
-    }
-    return data;
-  }
-};
-
-// src/data-source/in-memory-data-source.ts
-var InMemoryDataSource = class {
-  data;
-  projectId;
-  constructor(data, projectId) {
-    this.data = data;
-    this.projectId = projectId;
-  }
-  async getData() {
-    return this.data;
-  }
-};
-
-// src/index.ts
-var defaultFlagsClient = null;
-function parseFlagsConnectionString(connectionString) {
-  const errorMessage = "flags: Invalid connection string";
-  try {
-    const params = new URLSearchParams(connectionString.slice(6));
-    const edgeConfigId = params.get("edgeConfigId");
-    const edgeConfigToken = params.get("edgeConfigToken");
-    const projectId = params.get("projectId");
-    if (!edgeConfigId || !edgeConfigToken || !projectId) {
-      throw new Error(errorMessage);
-    }
-    return {
-      edgeConfigId,
-      edgeConfigToken,
-      projectId,
-      edgeConfigItemKey: params.get("edgeConfigItemKey"),
-      env: params.get("env")
-    };
-  } catch {
-    throw new Error(errorMessage);
-  }
-}
-function resetDefaultFlagsClient() {
-  defaultFlagsClient = null;
-}
-function createClientFromConnectionString(connectionString) {
-  if (!connectionString) {
-    throw new Error("flags: Missing connection string");
-  }
-  const connectionOptions = parseFlagsConnectionString(connectionString);
-  const edgeConfigItemKey = connectionOptions.edgeConfigItemKey || "flags";
-  if (!connectionOptions.edgeConfigId || !connectionOptions.edgeConfigToken) {
-    throw new Error("flags: Missing edge config connection information");
-  }
-  const edgeConfigConnectionString = `https://edge-config.vercel.com/${connectionOptions.edgeConfigId}?token=${connectionOptions.edgeConfigToken}`;
-  const edgeConfigClient = createEdgeConfigClient(edgeConfigConnectionString);
-  const dataSource = new EdgeConfigDataSource({
-    edgeConfigClient,
-    edgeConfigItemKey,
-    projectId: connectionOptions.projectId
-  });
-  const environment = getFlagsEnvironment(connectionOptions.env);
-  return createClient({ dataSource, environment });
-}
-function getDefaultFlagsClient() {
-  if (defaultFlagsClient)
-    return defaultFlagsClient;
-  if (!process.env.FLAGS) {
-    throw new Error("flags: Missing environment variable FLAGS");
-  }
-  defaultFlagsClient = createClientFromConnectionString(process.env.FLAGS);
-  return defaultFlagsClient;
-}
-function getFlagsEnvironment(connectionOptionsEnv) {
-  if (connectionOptionsEnv) {
-    return connectionOptionsEnv;
-  }
-  const vercelEnv = process.env.VERCEL_ENV;
-  if (!vercelEnv || vercelEnv === "development") {
-    return "development";
-  }
-  if (vercelEnv === "production") {
-    return "production";
-  }
-  return "preview";
-}
-
-export {
-  ResolutionReason,
-  evaluate,
-  createClient,
-  store,
-  EdgeConfigDataSource,
-  InMemoryDataSource,
-  parseFlagsConnectionString,
-  resetDefaultFlagsClient,
-  createClientFromConnectionString,
-  getDefaultFlagsClient,
-  getFlagsEnvironment
-};
-//# sourceMappingURL=chunk-4IFGPGNY.js.map