@@ -41,6 +41,7 @@ This picture show how we get the source code.
 ---
 ### G
 * Gatsby Homepage (https://www.gatsbyjs.com) - Landing Page / [Khoa Huynh](https://.com/htdangkhoa), 2021/09/21
+* Glitch (https://glitch.com) - Codesandbox / Nguy Thang, 2021/09/23
 
 ---
 ### H

@@ -0,0 +1,2 @@
+Shared React components for community & editor:
+https://.com/glitchdotcom/shared-components

@@ -0,0 +1,117 @@
+/**
+* Copyright 2016, 2018-2020, Optimizely
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+import {
+sprintf
+} from '@optimizely/js-sdk-utils';
+import {
+getLogger
+} from '@optimizely/js-sdk-logging';
+
+import fns from '../../utils/fns';
+import {
+LOG_LEVEL,
+LOG_MESSAGES,
+ERROR_MESSAGES,
+} from '../../utils/enums';
+import * as conditionTreeEvaluator from '../condition_tree_evaluator';
+import * as customAttributeConditionEvaluator from '../custom_attribute_condition_evaluator';
+
+var logger = getLogger();
+var MODULE_NAME = 'AUDIENCE_EVALUATOR';
+
+/**
+* Construct an instance of AudienceEvaluator with given options
+* @param {Object=} UNSTABLE_conditionEvaluators A map of condition evaluators provided by the consumer. This enables matching
+* condition types which are not supported natively by the SDK. Note that built in
+* Optimizely evaluators cannot be overridden.
+* @constructor
+*/
+function AudienceEvaluator(UNSTABLE_conditionEvaluators) {
+this.typeToEvaluatorMap = fns.assign({}, UNSTABLE_conditionEvaluators, {
+custom_attribute: customAttributeConditionEvaluator,
+});
+}
+
+/**
+* Determine if the given user attributes satisfy the given audience conditions
+* @param {Array|String|null|undefined} audienceConditions Audience conditions to match the user attributes against - can be an array
+* of audience IDs, a nested array of conditions, or a single leaf condition.
+* Examples: ["5", "6"], ["and", ["or", "1", "2"], "3"], "1"
+* @param {Object} audiencesById Object providing access to full audience objects for audience IDs
+* contained in audienceConditions. Keys should be audience IDs, values
+* should be full audience objects with conditions properties
+* @param {Object} [userAttributes] User attributes which will be used in determining if audience conditions
+* are met. If not provided, defaults to an empty object
+* @return {Boolean} true if the user attributes match the given audience conditions, false
+* otherwise
+*/
+AudienceEvaluator..evaluate = function(audienceConditions, audiencesById, userAttributes) {
+// if there are no audiences, return true because that means ALL users are included in the experiment
+if (!audienceConditions || audienceConditions.length === 0) {
+return true;
+}
+
+if (!userAttributes) {
+userAttributes = {};
+}
+
+var evaluateAudience = function(audienceId) {
+var audience = audiencesById[audienceId];
+if (audience) {
+logger.log(
+LOG_LEVEL.DEBUG,
+sprintf(LOG_MESSAGES.EVALUATING_AUDIENCE, MODULE_NAME, audienceId, JSON.stringify(audience.conditions))
+);
+var result = conditionTreeEvaluator.evaluate(
+audience.conditions,
+this.evaluateConditionWithUserAttributes.bind(this, userAttributes)
+);
+var resultText = result === null ? 'UNKNOWN' : result.toString().toUpperCase();
+logger.log(LOG_LEVEL.DEBUG, sprintf(LOG_MESSAGES.AUDIENCE_EVALUATION_RESULT, MODULE_NAME, audienceId, resultText));
+return result;
+}
+
+return null;
+}.bind(this);
+
+return conditionTreeEvaluator.evaluate(audienceConditions, evaluateAudience) || false;
+};
+
+/**
+* Wrapper around evaluator.evaluate that is passed to the conditionTreeEvaluator.
+* Evaluates the condition provided given the user attributes if an evaluator has been defined for the condition type.
+* @param {Object} userAttributes A map of user attributes.
+* @param {Object} condition A single condition object to evaluate.
+* @return {Boolean|null} true if the condition is satisfied, null if a matcher is not found.
+*/
+AudienceEvaluator..evaluateConditionWithUserAttributes = function(userAttributes, condition) {
+var evaluator = this.typeToEvaluatorMap[condition.type];
+if (!evaluator) {
+logger.log(LOG_LEVEL.WARNING, sprintf(LOG_MESSAGES.UNKNOWN_CONDITION_TYPE, MODULE_NAME, JSON.stringify(condition)));
+return null;
+}
+try {
+return evaluator.evaluate(condition, userAttributes, logger);
+} catch (err) {
+logger.log(
+LOG_LEVEL.ERROR,
+sprintf(ERROR_MESSAGES.CONDITION_EVALUATOR_ERROR, MODULE_NAME, condition.type, err.message)
+);
+}
+return null;
+};
+
+export default AudienceEvaluator;

@@ -0,0 +1,189 @@
+/**
+* Copyright 2016, 2019-2020, Optimizely
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/**
+* Bucketer API for determining the variation id from the specified parameters
+*/
+import {
+sprintf
+} from '@optimizely/js-sdk-utils';
+import murmurhash from 'murmurhash';
+
+import {
+ERROR_MESSAGES,
+LOG_LEVEL,
+LOG_MESSAGES,
+} from '../../utils/enums';
+
+var HASH_SEED = 1;
+var MAX_HASH_VALUE = Math.pow(2, 32);
+var MAX_TRAFFIC_VALUE = 10000;
+var MODULE_NAME = 'BUCKETER';
+var RANDOM_POLICY = 'random';
+
+/**
+* Determines ID of variation to be shown for the given input params
+* @param {Object} bucketerParams
+* @param {string} bucketerParams.experimentId
+* @param {string} bucketerParams.experimentKey
+* @param {string} bucketerParams.userId
+* @param {Object[]} bucketerParams.trafficAllocationConfig
+* @param {Array} bucketerParams.experimentKeyMap
+* @param {Object} bucketerParams.groupIdMap
+* @param {Object} bucketerParams.variationIdMap
+* @param {string} bucketerParams.varationIdMap[].key
+* @param {Object} bucketerParams.logger
+* @param {string} bucketerParams.bucketingId
+* @return Variation ID that user has been bucketed into, null if user is not bucketed into any experiment
+*/
+export var bucket = function(bucketerParams) {
+// Check if user is in a random group; if so, check if user is bucketed into a specific experiment
+var experiment = bucketerParams.experimentKeyMap[bucketerParams.experimentKey];
+var groupId = experiment['groupId'];
+if (groupId) {
+var group = bucketerParams.groupIdMap[groupId];
+if (!group) {
+throw new Error(sprintf(ERROR_MESSAGES.INVALID_GROUP_ID, MODULE_NAME, groupId));
+}
+if (group.policy === RANDOM_POLICY) {
+var bucketedExperimentId = this.bucketUserIntoExperiment(
+group,
+bucketerParams.bucketingId,
+bucketerParams.userId,
+bucketerParams.logger
+);
+
+// Return if user is not bucketed into any experiment
+if (bucketedExperimentId === null) {
+var notbucketedInAnyExperimentLogMessage = sprintf(
+LOG_MESSAGES.USER_NOT_IN_ANY_EXPERIMENT,
+MODULE_NAME,
+bucketerParams.userId,
+groupId
+);
+bucketerParams.logger.log(LOG_LEVEL.INFO, notbucketedInAnyExperimentLogMessage);
+return null;
+}
+
+// Return if user is bucketed into a different experiment than the one specified
+if (bucketedExperimentId !== bucketerParams.experimentId) {
+var notBucketedIntoExperimentOfGroupLogMessage = sprintf(
+LOG_MESSAGES.USER_NOT_BUCKETED_INTO_EXPERIMENT_IN_GROUP,
+MODULE_NAME,
+bucketerParams.userId,
+bucketerParams.experimentKey,
+groupId
+);
+bucketerParams.logger.log(LOG_LEVEL.INFO, notBucketedIntoExperimentOfGroupLogMessage);
+return null;
+}
+
+// Continue bucketing if user is bucketed into specified experiment
+var bucketedIntoExperimentOfGroupLogMessage = sprintf(
+LOG_MESSAGES.USER_BUCKETED_INTO_EXPERIMENT_IN_GROUP,
+MODULE_NAME,
+bucketerParams.userId,
+bucketerParams.experimentKey,
+groupId
+);
+bucketerParams.logger.log(LOG_LEVEL.INFO, bucketedIntoExperimentOfGroupLogMessage);
+}
+}
+var bucketingId = sprintf('%s%s', bucketerParams.bucketingId, bucketerParams.experimentId);
+var bucketValue = this._generateBucketValue(bucketingId);
+
+var bucketedUserLogMessage = sprintf(
+LOG_MESSAGES.USER_ASSIGNED_TO_EXPERIMENT_BUCKET,
+MODULE_NAME,
+bucketValue,
+bucketerParams.userId
+);
+bucketerParams.logger.log(LOG_LEVEL.DEBUG, bucketedUserLogMessage);
+
+var entityId = this._findBucket(bucketValue, bucketerParams.trafficAllocationConfig);
+
+if (!bucketerParams.variationIdMap.hasOwnProperty(entityId)) {
+if (entityId) {
+var invalidVariationIdLogMessage = sprintf(LOG_MESSAGES.INVALID_VARIATION_ID, MODULE_NAME);
+bucketerParams.logger.log(LOG_LEVEL.WARNING, invalidVariationIdLogMessage);
+}
+return null;
+}
+
+return entityId;
+};
+
+/**
+* Returns bucketed experiment ID to compare against experiment user is being called into
+* @param {Object} group Group that experiment is in
+* @param {string} bucketingId Bucketing ID
+* @param {string} userId ID of user to be bucketed into experiment
+* @param {Object} logger Logger implementation
+* @return {string|null} ID of experiment if user is bucketed into experiment within the group, null otherwise
+*/
+export var bucketUserIntoExperiment = function(group, bucketingId, userId, logger) {
+var bucketingKey = sprintf('%s%s', bucketingId, group.id);
+var bucketValue = this._generateBucketValue(bucketingKey);
+logger.log(
+LOG_LEVEL.DEBUG,
+sprintf(LOG_MESSAGES.USER_ASSIGNED_TO_EXPERIMENT_BUCKET, MODULE_NAME, bucketValue, userId)
+);
+var trafficAllocationConfig = group.trafficAllocation;
+var bucketedExperimentId = this._findBucket(bucketValue, trafficAllocationConfig);
+return bucketedExperimentId;
+};
+
+/**
+* Returns entity ID associated with bucket value
+* @param {string} bucketValue
+* @param {Object[]} trafficAllocationConfig
+* @param {number} trafficAllocationConfig[].endOfRange
+* @param {number} trafficAllocationConfig[].entityId
+* @return {string|null} Entity ID for bucketing if bucket value is within traffic allocation boundaries, null otherwise
+*/
+export var _findBucket = function(bucketValue, trafficAllocationConfig) {
+for (var i = 0; i < trafficAllocationConfig.length; i++) {
+if (bucketValue < trafficAllocationConfig[i].endOfRange) {
+return trafficAllocationConfig[i].entityId;
+}
+}
+return null;
+};
+
+/**
+* Helper function to generate bucket value in half-closed interval [0, MAX_TRAFFIC_VALUE)
+* @param {string} bucketingKey String value for bucketing
+* @return {string} the generated bucket value
+* @throws If bucketing value is not a valid string
+*/
+export var _generateBucketValue = function(bucketingKey) {
+try {
+// NOTE: the mmh library already does cast the hash value as an unsigned 32bit int
+// https://.com/perezd/node-murmurhash/blob/master/murmurhash.js#L115
+var hashValue = murmurhash.v3(bucketingKey, HASH_SEED);
+var ratio = hashValue / MAX_HASH_VALUE;
+return parseInt(ratio * MAX_TRAFFIC_VALUE, 10);
+} catch (ex) {
+throw new Error(sprintf(ERROR_MESSAGES.INVALID_BUCKETING_ID, MODULE_NAME, bucketingKey, ex.message));
+}
+};
+
+export default {
+bucket: bucket,
+bucketUserIntoExperiment: bucketUserIntoExperiment,
+_findBucket: _findBucket,
+_generateBucketValue: _generateBucketValue,
+};