launchdarkly
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎.ldrelease/config.yml‎
Lines changed: 2 additions & 1 deletion b/‎.ldrelease/config.yml‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎attribute_reference.js‎
Lines changed: 217 additions & 0 deletions b/‎attribute_reference.js‎
Lines changed: 217 additions & 0 deletions
diff --git a/‎configuration.js‎
Lines changed: 8 additions & 5 deletions b/‎configuration.js‎
Lines changed: 8 additions & 5 deletions
diff --git a/‎context.js‎
Lines changed: 98 additions & 0 deletions b/‎context.js‎
Lines changed: 98 additions & 0 deletions
@@ -6,3 +6,4 @@ junit.xml
 npm-debug.log
 test-types.js
 .vscode
+coverage/
@@ -6,7 +6,8 @@ repo:
 
 branches:
   - name: main
-    description: 6.x
+    description: 7.x
+  - name: 6.x
   - name: 5.x
 
 publications:
 
@@ -0,0 +1,217 @@
+/**
+ * Take a key string and escape the characters to allow it to be used as a reference.
+ * @param {string} key
+ * @returns {string} The processed key.
+ */
+function processEscapeCharacters(key) {
+  return key.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+
+/**
+ * @param {string} reference The reference to get the components of.
+ * @returns {string[]} The components of the reference. Escape characters will be converted to their representative values.
+ */
+function getComponents(reference) {
+  const referenceWithoutPrefix = reference.startsWith('/') ? reference.substring(1) : reference;
+  return referenceWithoutPrefix
+    .split('/')
+    .map(component => (component.indexOf('~') >= 0 ? component.replace(/~1/g, '/').replace(/~0/g, '~') : component));
+}
+
+/**
+ * @param {string} reference The reference to check if it is a literal.
+ * @returns true if the reference is a literal.
+ */
+function isLiteral(reference) {
+  return !reference.startsWith('/');
+}
+
+/**
+ * Get an attribute value from a literal.
+ * @param {Object} target
+ * @param {string} literal
+ */
+function getFromLiteral(target, literal) {
+  if (target !== null && target !== undefined && Object.prototype.hasOwnProperty.call(target, literal)) {
+    return target[literal];
+  }
+}
+
+/**
+ * Gets the `target` object's value at the `reference`'s location.
+ *
+ * This method method follows the rules for accessing attributes for use
+ * in evaluating clauses.
+ *
+ * Accessing the root of the target will always result in undefined.
+ *
+ * @param {Object} target
+ * @param {string} reference
+ * @returns The `target` object's value at the `reference`'s location.
+ * Undefined if the field does not exist or if the reference is not valid.
+ */
+function get(target, reference) {
+  if (reference === '' || reference === '/') {
+    return undefined;
+  }
+
+  if (isLiteral(reference)) {
+    return getFromLiteral(target, reference);
+  }
+
+  const components = getComponents(reference);
+  let current = target;
+  for (const component of components) {
+    if (
+      current !== null &&
+      current !== undefined &&
+      typeof current === 'object' &&
+      // We do not want to allow indexing into an array.
+      !Array.isArray(current) &&
+      // For arrays and strings, in addition to objects, a hasOwnProperty check
+      // will be true for indexes (as strings or numbers), which are present
+      // in the object/string/array.
+      Object.prototype.hasOwnProperty.call(current, component)
+    ) {
+      current = current[component];
+    } else {
+      return undefined;
+    }
+  }
+
+  return current;
+}
+
+/**
+ * Compare two references and determine if they are equivalent.
+ * @param {string} a
+ * @param {string} b
+ */
+function compare(a, b) {
+  const aIsLiteral = isLiteral(a);
+  const bIsLiteral = isLiteral(b);
+  if (aIsLiteral && bIsLiteral) {
+    return a === b;
+  }
+  if (aIsLiteral) {
+    const bComponents = getComponents(b);
+    if (bComponents.length !== 1) {
+      return false;
+    }
+    return a === bComponents[0];
+  }
+  if (bIsLiteral) {
+    const aComponents = getComponents(a);
+    if (aComponents.length !== 1) {
+      return false;
+    }
+    return b === aComponents[0];
+  }
+  return a === b;
+}
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @returns The two strings joined by '/'.
+ */
+function join(a, b) {
+  return `${a}/${b}`;
+}
+
+/**
+ * There are cases where a field could have been named with a preceeding '/'.
+ * If that attribute was private, then the literal would appear to be a reference.
+ * This method can be used to convert a literal to a reference in such situations.
+ * @param {string} literal The literal to convert to a reference.
+ * @returns A literal which has been converted to a reference.
+ */
+function literalToReference(literal) {
+  return `/${processEscapeCharacters(literal)}`;
+}
+
+/**
+ * Clone an object excluding the values referenced by a list of references.
+ * @param {Object} target The object to clone.
+ * @param {string[]} references A list of references from the cloned object.
+ * @returns {{cloned: Object, excluded: string[]}} The cloned object and a list of excluded values.
+ */
+function cloneExcluding(target, references) {
+  const stack = [];
+  const cloned = {};
+  const excluded = [];
+
+  stack.push(
+    ...Object.keys(target).map(key => ({
+      key,
+      ptr: literalToReference(key),
+      source: target,
+      parent: cloned,
+      visited: [target],
+    }))
+  );
+
+  while (stack.length) {
+    const item = stack.pop();
+    if (!references.some(ptr => compare(ptr, item.ptr))) {
+      const value = item.source[item.key];
+
+      // Handle null because it overlaps with object, which we will want to handle later.
+      if (value === null) {
+        item.parent[item.key] = value;
+      } else if (Array.isArray(value)) {
+        item.parent[item.key] = [...value];
+      } else if (typeof value === 'object') {
+        //Arrays and null must already be handled.
+
+        //Prevent cycles by not visiting the same object
+        //with in the same branch. Parallel branches
+        //may contain the same object.
+        if (item.visited.includes(value)) {
+          continue;
+        }
+
+        item.parent[item.key] = {};
+
+        stack.push(
+          ...Object.keys(value).map(key => ({
+            key,
+            ptr: join(item.ptr, processEscapeCharacters(key)),
+            source: value,
+            parent: item.parent[item.key],
+            visited: [...item.visited, value],
+          }))
+        );
+      } else {
+        item.parent[item.key] = value;
+      }
+    } else {
+      excluded.push(item.ptr);
+    }
+  }
+  return { cloned, excluded: excluded.sort() };
+}
+
+function isValidReference(reference) {
+  return !reference.match(/\/\/|(^\/.*~[^0|^1])|~$/);
+}
+
+/**
+ * Check if the given attribute reference is for the "kind" attribute.
+ * @param {string} reference String containing an attribute reference.
+ */
+function isKind(reference) {
+  // There are only 2 valid ways to specify the kind attribute,
+  // so this just checks them. Given the current flow of evaluation
+  // this is much less intense a process than doing full validation and parsing.
+  return reference === 'kind' || reference === '/kind';
+}
+
+module.exports = {
+  cloneExcluding,
+  compare,
+  get,
+  isValidReference,
+  literalToReference,
+  isKind,
+};
@@ -18,10 +18,9 @@ module.exports = (function () {
       offline: false,
       useLdd: false,
       allAttributesPrivate: false,
-      privateAttributeNames: [],
-      inlineUsersInEvents: false,
-      userKeysCapacity: 1000,
-      userKeysFlushInterval: 300,
+      privateAttributes: [],
+      contextKeysCapacity: 1000,
+      contextKeysFlushInterval: 300,
       diagnosticOptOut: false,
       diagnosticRecordingInterval: 900,
       featureStore: InMemoryFeatureStore(),
@@ -89,7 +88,10 @@ module.exports = (function () {
   };
 
   /* eslint-disable camelcase */
-  const deprecatedOptions = {};
+  const deprecatedOptions = {
+    userKeysCapacity: 'contextKeysCapacity',
+    userKeysFlushInterval: 'contextKeysFlushInterval',
+  };
   /* eslint-enable camelcase */
 
   function checkDeprecatedOptions(configIn) {
@@ -137,6 +139,7 @@ module.exports = (function () {
       }
       return 'object';
     };
+
     Object.keys(config).forEach(name => {
       const value = config[name];
       if (value !== null && value !== undefined) {
 
@@ -0,0 +1,98 @@
+/**
+ * Validate a context kind.
+ * @param {string} kind
+ * @returns true if the kind is valid.
+ */
+function validKind(kind) {
+  return typeof kind === 'string' && kind !== 'kind' && kind.match(/^(\w|\.|-)+$/);
+}
+
+/**
+ * Validate a context key.
+ * @param {string} key
+ * @returns true if the key is valid.
+ */
+function validKey(key) {
+  return key !== undefined && key !== null && key !== '' && typeof key === 'string';
+}
+
+/**
+ * Perform a check of basic context requirements.
+ * @param {Object} context
+ * @param {boolean} allowLegacyKey If true, then a legacy user can have an
+ * empty or non-string key. A legacy user is a context without a kind.
+ * @returns true if the context meets basic requirements.
+ */
+function checkContext(context, allowLegacyKey) {
+  if (context) {
+    if (allowLegacyKey && (context.kind === undefined || context.kind === null)) {
+      return context.key !== undefined && context.key !== null;
+    }
+    const key = context.key;
+    const kind = context.kind === undefined ? 'user' : context.kind;
+    const kindValid = validKind(kind);
+    const keyValid = kind === 'multi' || validKey(key);
+    if (kind === 'multi') {
+      const kinds = Object.keys(context).filter(key => key !== 'kind');
+      return keyValid && kinds.every(key => validKind(key)) && kinds.every(key => validKey(context[key].key));
+    }
+    return keyValid && kindValid;
+  }
+  return false;
+}
+
+/**
+ * The partial URL encoding is needed because : is a valid character in context keys.
+ *
+ * Partial encoding is the replacement of all colon (:) characters with the URL
+ * encoded equivalent (%3A) and all percent (%) characters with the URL encoded
+ * equivalent (%25).
+ * @param {string} key The key to encode.
+ * @returns {string} Partially URL encoded key.
+ */
+function encodeKey(key) {
+  if (key.includes('%') || key.includes(':')) {
+    return key.replace(/%/g, '%25').replace(/:/g, '%3A');
+  }
+  return key;
+}
+
+/**
+ * For a given context get a list of context kinds.
+ * @param {Object} context
+ * @returns A list of kinds in the context.
+ */
+function getContextKinds(context) {
+  if (context) {
+    if (context.kind === null || context.kind === undefined) {
+      return ['user'];
+    }
+    if (context.kind !== 'multi') {
+      return [context.kind];
+    }
+    return Object.keys(context).filter(kind => kind !== 'kind');
+  }
+  return [];
+}
+
+function getCanonicalKey(context) {
+  if (context) {
+    if ((context.kind === undefined || context.kind === null || context.kind === 'user') && context.key) {
+      return context.key;
+    } else if (context.kind !== 'multi' && context.key) {
+      return `${context.kind}:${encodeKey(context.key)}`;
+    } else if (context.kind === 'multi') {
+      return Object.keys(context)
+        .sort()
+        .filter(key => key !== 'kind')
+        .map(key => `${key}:${encodeKey(context[key].key)}`)
+        .join(':');
+    }
+  }
+}
+
+module.exports = {
+  checkContext,
+  getContextKinds,
+  getCanonicalKey,
+};