@zcomponent/core 0.0.31-beta → 0.1.0-beta

package/lib/index.d.ts

@@ -1,3 +1,4 @@
+export { ValuesManager } from './values/values';
 export * from './component';
 export * from './behavior';
 export * from './actionbehavior';

package/lib/index.js

@@ -1,3 +1,4 @@
+export { ValuesManager } from './values/values';
 export * from './component';
 export * from './behavior';
 export * from './actionbehavior';

package/lib/profile.d.ts

@@ -0,0 +1,13 @@
+export declare enum DeviceType {
+    DESKTOP = "desktop",
+    MOBILE = "mobile"
+}
+export declare class Profile {
+    isDesktop: boolean;
+    muteByDefault: boolean;
+    clientLanguage: string;
+    urlSearchParams: URLSearchParams;
+    debugMode: boolean;
+    constructor();
+    get userAgent(): DeviceType;
+}

package/lib/profile.js

@@ -0,0 +1,26 @@
+export var DeviceType;
+(function (DeviceType) {
+    DeviceType["DESKTOP"] = "desktop";
+    DeviceType["MOBILE"] = "mobile";
+})(DeviceType || (DeviceType = {}));
+function getDeviceType() {
+    const userAgent = window.navigator.userAgent;
+    const mobileKeywords = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
+    if (mobileKeywords.test(userAgent)) {
+        return DeviceType.MOBILE;
+    }
+    return DeviceType.DESKTOP;
+}
+export class Profile {
+    constructor() {
+        this.muteByDefault = false;
+        this.clientLanguage = window.navigator.language;
+        this.debugMode = false;
+        this.urlSearchParams = new URLSearchParams(window.location.search);
+        this.debugMode = this.urlSearchParams.has('debug') && this.urlSearchParams.get('debug') === 'true';
+        this.isDesktop = getDeviceType() === DeviceType.DESKTOP;
+    }
+    get userAgent() {
+        return this.isDesktop ? DeviceType.DESKTOP : DeviceType.MOBILE;
+    }
+}

package/lib/selectors.d.ts

@@ -1,6 +1,7 @@
 import { BehaviorByID, EntityPropOverride, Import, NodeByID, ParsedImport, Props, ZComponentData } from './data/core';
 import * as Data from './data';
 import { Layer } from './animation';
+import { ZValues } from './values/values';
 export declare function parseImport(i: Import): ParsedImport;
 export declare function constructImport(from: string, destFile: string, imp: string): string;
 export declare function getScriptName(n: string, requireUniqueIn: string[] | {
@@ -32,3 +33,4 @@ export declare function propertyTracksByEntityID(clip: Data.Clip): {
 };
 export declare function getBehaviorBlockForNode(behaviors: BehaviorByID, behaviorIDs: string[], importMapping: Map<string, string>): string;
 export declare function importNameWithoutExt(imp: string): string;
+export declare const typeDefinitionForZValues: (values: ZValues, url: string) => string;

package/lib/selectors.js

@@ -2,6 +2,7 @@ import { EntityPropOverrideType } from './data/core';
 import * as path from 'path';
 import { outputForType } from './types';
 import * as Data from './data';
+import * as VALUES from './values/valuesmutator';
 import { computeBehaviorHierarchy } from './data';
 export function parseImport(i) {
     if (typeof i !== 'string')
@@ -221,7 +222,9 @@ export const typeDefinitionForComponent = (nodes, props, constructorProps, scrip
 ${importStrings.join('\n')}
 
 interface ConstructorProps {
-${Object.values(constructorProps ?? {}).map(typeOutputForConstructorProp).join('\n\n')}
+${Object.values(constructorProps ?? {})
+        .map(typeOutputForConstructorProp)
+        .join('\n\n')}
 }
 
 /**
@@ -255,12 +258,16 @@ export default Comp;
 function typeForAnimation(layers) {
     const layersWithScriptNames = Object.values(layers).filter(l => l?.scriptName !== undefined);
     return `Animation & { layers: {
-${Object.values(layersWithScriptNames).map(layer => {
+${Object.values(layersWithScriptNames)
+        .map(layer => {
         const clipsWithScriptNames = Object.values(layer.clips).filter(lc => lc?.scriptName !== undefined);
         return `\t\t${layer.scriptName ?? '""'}: Layer & { clips: {
-${Object.values(clipsWithScriptNames).map(lc => `\t\t\t${lc.scriptName ?? '""'}: LayerClip;`).join('\n')}
+${Object.values(clipsWithScriptNames)
+            .map(lc => `\t\t\t${lc.scriptName ?? '""'}: LayerClip;`)
+            .join('\n')}
 		}};`;
-    }).join('\n')}
+    })
+        .join('\n')}
 	}};`;
 }
 function makeCommentSafe(c) {
@@ -268,7 +275,7 @@ function makeCommentSafe(c) {
 }
 function getJSDocForProp(prop) {
     let lines = [];
-    for (const comment of (prop.comments ?? [])) {
+    for (const comment of prop.comments ?? []) {
         lines.push(...comment.split('\n'));
     }
     if (lines.length > 0)
@@ -345,3 +352,24 @@ export function importNameWithoutExt(imp) {
         return imp.substring(0, imp.length - 3);
     return imp;
 }
+export const typeDefinitionForZValues = (values, url) => {
+    const code = [];
+    const defaults = VALUES.getTypesAndDefaultsByKey(values);
+    defaults.forEach((def, keyName) => {
+        const type = def[0];
+        const defaultValue = def[1];
+        code.push(typeOutputForZValueKey(keyName, type, defaultValue));
+    });
+    // const _values = values.map(typeOutputForZValueKey).join('\n');
+    return `import { Observable } from "@zcomponent/core";
+${code.join('\n')}`;
+};
+function typeOutputForZValueKey(keyName, _type, defaultValue) {
+    // TODO: Description
+    // const description = value.description ? `@description ${JSON.stringify(value.description)}` : '*';
+    return `/**
+* ${defaultValue && `@default ${JSON.stringify(defaultValue)}`}
+* @zui
+*/
+export declare const ${keyName}: Observable<${outputForType(_type)}${defaultValue === undefined ? '| undefined' : ''}>;`;
+}

package/lib/types.d.ts

@@ -1,4 +1,4 @@
-import { EntityPropOverride } from "./data/core";
+import { EntityPropOverride } from './data/core';
 export interface BaseType {
     comments?: string[];
     typeHint?: TypeHint;
@@ -110,7 +110,7 @@ export interface DefaultChild {
         [id: string]: any;
     };
 }
-export type ComponentInfoType = "component" | "behavior" | "context";
+export type ComponentInfoType = 'component' | 'behavior' | 'context';
 export interface ComponentInfo {
     name: string;
     file: string;
@@ -180,3 +180,4 @@ export declare function overridesAreCompatible(a: {
 }, b: {
     [path: string]: EntityPropOverride;
 }): boolean;
+export declare function defaultValueForType(t: Type): any;

package/lib/types.js

@@ -1,5 +1,5 @@
-import { EntityPropOverrideType } from "./data/core";
-import { getSafeKeyName } from "./selectors";
+import { EntityPropOverrideType } from './data/core';
+import { getSafeKeyName } from './selectors';
 export var TypeName;
 (function (TypeName) {
     TypeName["String"] = "string";
@@ -66,9 +66,9 @@ export function areTypesCompatible(a, b) {
         }
         case 'union': {
             const bt = b;
-            for (let achild of a.children) {
+            for (const achild of a.children) {
                 let foundCompatible = false;
-                for (let bchild of bt.children) {
+                for (const bchild of bt.children) {
                     if (areTypesCompatible(achild, bchild)) {
                         foundCompatible = true;
                         break;
@@ -411,3 +411,19 @@ function overrideAreCompatible(a, b) {
         return false;
     return true;
 }
+export function defaultValueForType(t) {
+    switch (t.name) {
+        case 'array':
+            return [];
+        case 'tuple':
+            return t.children.map(c => defaultValueForType(c));
+        case 'unknown':
+            return '{}';
+        case 'number':
+            return 0;
+        case 'string':
+            return '';
+        case 'boolean':
+            return false;
+    }
+}

package/lib/validators.d.ts

@@ -1,8 +1,10 @@
 import { Import, NodeData, ZComponentData } from './data/core';
+import type { ZValues } from './values/values';
 interface Issue {
     text: string;
 }
 export declare const validateImport: (i: Import) => Issue[];
+export declare const validatorZValuesTopLevel: (url: string, values: ZValues) => Issue[];
 export declare const validatorZcomponentTopLevel: (url: string, component: ZComponentData) => Issue[];
 export declare const validatorZcomponentComponent: (node: NodeData, nodeId: string) => Issue[];
 export {};

package/lib/validators.js

@@ -5,6 +5,12 @@ export const validateImport = (i) => {
         return [{ text: 'Import structure is invalid' }];
     return [];
 };
+export const validatorZValuesTopLevel = (url, values) => {
+    if (typeof values !== 'object' || typeof values.keys !== 'object' || typeof values.values !== 'object' || typeof values.variantsByID !== 'object') {
+        return [{ text: 'values structure is invalid' }];
+    }
+    return [];
+};
 export const validatorZcomponentTopLevel = (url, component) => {
     if (typeof component !== 'object' ||
         typeof component.nodes !== 'object' ||

package/lib/values/values.d.ts

@@ -0,0 +1,61 @@
+import { DeviceType } from '../profile';
+import type { Type } from '../types';
+export declare enum ConditionType {
+    'Locale' = "Locale",
+    'QueryString' = "Query String",
+    'UserAgent' = "User Agent",
+    'Debug' = "Debug",
+    'Default' = "Default"
+}
+export declare function getTypeForVariant(variant: ConditionType): Type;
+export interface BaseVariant {
+    conditionType: ConditionType;
+    priority: number;
+}
+export interface DefaultVariant {
+    conditionType: ConditionType.Default;
+    priority: number;
+}
+export interface LocaleVariant extends BaseVariant {
+    conditionType: ConditionType.Locale;
+    code?: string;
+}
+export interface QueryStringVariant extends BaseVariant {
+    conditionType: ConditionType.QueryString;
+    param?: string;
+    value?: string;
+}
+export interface UserAgentVariant extends BaseVariant {
+    conditionType: ConditionType.UserAgent;
+    agent?: DeviceType;
+}
+export interface DebugVariant extends BaseVariant {
+    conditionType: ConditionType.Debug;
+    isEnabled?: boolean;
+}
+export type ZVariant = LocaleVariant | QueryStringVariant | UserAgentVariant | DebugVariant | DefaultVariant;
+export declare class ValuesManager {
+    private valuesString;
+    private profile;
+    constructor(valuesString: string, states: Map<string, any>);
+    private getValueForKey;
+    private getEnabledStateOfVariant;
+}
+export type ZValuesKey = {
+    type: Type;
+};
+export type ZValuesKeys = {
+    [key: string]: ZValuesKey;
+};
+export type ZValuesValues = {
+    [key: string]: {
+        [key: string]: any;
+    };
+};
+export type ZValues = {
+    keys: ZValuesKeys;
+    variantsByID: {
+        [id: string]: ZVariant;
+    };
+    values: ZValuesValues;
+};

package/lib/values/values.js

@@ -0,0 +1,91 @@
+import { Profile } from '../profile';
+export var ConditionType;
+(function (ConditionType) {
+    ConditionType["Locale"] = "Locale";
+    ConditionType["QueryString"] = "Query String";
+    ConditionType["UserAgent"] = "User Agent";
+    ConditionType["Debug"] = "Debug";
+    ConditionType["Default"] = "Default";
+})(ConditionType || (ConditionType = {}));
+export function getTypeForVariant(variant) {
+    switch (variant) {
+        case ConditionType.Locale:
+            return {
+                name: 'string',
+            };
+        case ConditionType.QueryString:
+            return {
+                name: 'unknown',
+            };
+        case ConditionType.UserAgent:
+            return {
+                name: 'unknown',
+            };
+        case ConditionType.Debug:
+            return {
+                name: 'boolean',
+            };
+        default:
+            throw new Error(`Unknown variant type: ${variant}`);
+    }
+}
+export class ValuesManager {
+    // TODO: Fix this any
+    constructor(valuesString, states) {
+        this.valuesString = valuesString;
+        this.profile = new Profile();
+        if (valuesString === undefined)
+            throw new Error('Values are not defined');
+        if (states === undefined)
+            throw new Error('States are not defined');
+        const values = JSON.parse(valuesString);
+        states.forEach((state, keyName) => {
+            const key = Object.keys(values.keys).find(v => v === keyName);
+            if (!key)
+                throw new Error(`No key found for state ${keyName}`);
+            const keyState = states.get(keyName);
+            if (!keyState)
+                throw new Error(`No state found for key ${keyName}`);
+            keyState.value = this.getValueForKey(key, values);
+        });
+    }
+    getValueForKey(key, values) {
+        const enableVariantIDs = new Set();
+        for (const variantID in values.variantsByID) {
+            const enabledState = this.getEnabledStateOfVariant(values.variantsByID[variantID]);
+            if (enabledState)
+                enableVariantIDs.add(variantID);
+        }
+        const highestPriorityVariantID = Array.from(enableVariantIDs).reduce((prev, curr) => {
+            const prevPriority = values.variantsByID[prev].priority;
+            const currPriority = values.variantsByID[curr].priority;
+            return prevPriority > currPriority ? prev : curr;
+        });
+        const value = values.values[key][highestPriorityVariantID];
+        return value;
+    }
+    getEnabledStateOfVariant(variant) {
+        let enabled = false;
+        switch (variant.conditionType) {
+            case ConditionType.Default:
+                enabled = true;
+                break;
+            case ConditionType.Locale:
+                enabled = variant.code === this.profile.clientLanguage;
+                break;
+            case ConditionType.QueryString:
+                if (variant.param) {
+                    const queryValue = this.profile.urlSearchParams.get(variant.param);
+                    enabled = (queryValue && queryValue === variant.value) || (queryValue === undefined && variant.value === undefined);
+                }
+                break;
+            case ConditionType.UserAgent:
+                enabled = variant.agent === this.profile.userAgent;
+                break;
+            case ConditionType.Debug:
+                enabled = variant.isEnabled === this.profile.debugMode;
+                break;
+        }
+        return enabled;
+    }
+}

package/lib/values/valuesmutator.d.ts

@@ -0,0 +1,127 @@
+import type { Type } from '../types';
+import type { ZValues, ZVariant } from './values';
+export declare function changeKeyAndType(values: ZValues, oldKeyName: string, newKeyName: string, type: Type): ZValues;
+type ValuesByType = {
+    value: any;
+    uuid: string;
+    priority: number;
+};
+export declare function getSortedValuesByType(values: ZValues): Map<string, {
+    values: ValuesByType[];
+    type: Type;
+}>;
+/**
+ * Given a uuid of an existing variant alongside a direction, shifts the priority of the variant in the direction.
+ * @param values The values to mutate
+ * @param uuid The uuid of the variant to shift
+ * @param direction The direction to shift the variant in
+ * @returns The mutated values
+ * @note The variant must exist in the values.
+ * @note The variant's priority will never be less than 1 as this is reserved for the default variant.
+ * @note the priority of the default variant will never change from 0.
+ */
+export declare function shiftPriorityLeftOrRightByUUID(values: ZValues, uuid: string, direction: 'left' | 'right'): ZValues;
+/**
+ *
+ * @param values The values to mutate.
+ * @param keyName The key to delete.
+ * @returns The mutated values.
+ */
+export declare function deleteKeyFromValues(values: ZValues, keyName: string): ZValues;
+/**
+ *
+ * @param values The values to mutate.
+ * @param uuid The uuid of the variant to shift.
+ * @param direction The direction to shift the variant in.
+ * @returns The mutated values.
+ */
+export declare function canShiftPriorityLeftOrRightByUUID(values: ZValues, uuid: string, direction: 'left' | 'right'): boolean;
+/**
+ *
+ * @param values The values to mutate.
+ * @param value The value to set.
+ * @param key The key to add the value to.
+ * @returns The mutated values.
+ */
+export declare function setDefaultValueForKey(values: ZValues, value: any, key: string): ZValues;
+/**
+ * Get the default value for a key.
+ * @param values The values to get the default value from.
+ * @param key The key to get the default value for.
+ * @returns The default value for the key, or undefined if no default value is set.
+ */
+export declare function getDefaultValueForKey(values: ZValues, key: string): any;
+/**
+ * Get a set of default values by key.
+ * @param values The values to get the default values from.
+ * @returns The default values by key.
+ */
+export declare function getDefaultValuesByKey(values: ZValues): Map<string, any>;
+/**
+ * @param values The values to parse.
+ * @returns A map of key names to their type representations.
+ */
+export declare function getTypesByKey(values: ZValues): Map<string, Type>;
+/**
+ *
+ * @param values The values to check.
+ * @returns Returns a map of key names to their [type representations, default values].
+ */
+export declare function getTypesAndDefaultsByKey(values: ZValues): Map<string, [Type, any]>;
+/**
+ * Adds a new key to the values.
+ * @param keyname The name of the key.
+ * @param type The type of the key.
+ * @param values The values to add the key to.
+ * @returns The new values.
+ */
+export declare function addNewKeyToValues(keyname: string, type: Type, values: ZValues): ZValues;
+/**
+ * Inserts a new key containing a default value into the values.
+ * @param keyname The name of the key.
+ * @param type The type of the key.
+ * @param values The values to add the key to.
+ * @param defaultValue The default value to set for the key.
+ * @returns The new values.
+ */
+export declare function addNewKeyToValuesWithDefaultValue(keyname: string, type: Type, values: ZValues, defaultValue: any): ZValues;
+/**
+ * Add a new variant to the values.
+ * @param uuid The uuid of the new variant.
+ * @param variant The variant to add.
+ * @param values The values to add the variant to.
+ * @returns The new values.
+ */
+export declare function addNewVariantToValues(values: ZValues, uuid: string, variant: ZVariant): ZValues;
+/**
+ *	Remove a variant from the values
+ * @param uuid The uuid of the variant to remove
+ * @param values The values to remove the variant from
+ * @returns The new values object
+ */
+export declare function removeVariantFromValuesByUUID(uuid: string, values: ZValues): ZValues;
+/**
+ * Returns a new values object with the value overridden.
+ * @param keyname The keyname of the value to override.
+ * @param variantID The variantID of the value to override.
+ * @param value The new value.
+ * @param values The values object to override.
+ * @returns
+ */
+export declare function changeValueInValues(keyname: string, uuid: string, value: any, values: ZValues): ZValues;
+/**
+ * Given a values object, returns a CSV string.
+ * @param values The values to convert to CSV.
+ * @returns A CSV string.
+ */
+export declare function ZValuesToCSVString(values: ZValues): string;
+/**
+ * Merges a provided csv string into the provided values object.
+ * @param csvString The csv string to merge (source)
+ * @param currentValues The values object to merge into (destination)
+ * @returns The new values object.
+ * @notes This can very likely be improved.
+ * @notes I couldn't quite figure out how to do it in a way that was cleaner than this.
+ */
+export declare function mergeCSVStringIntoTarget(csvString: string, currentValues: ZValues): ZValues;
+export {};

package/lib/values/valuesmutator.js

@@ -0,0 +1,513 @@
+import { ConditionType } from './values';
+export function changeKeyAndType(values, oldKeyName, newKeyName, type) {
+    if (!values.keys.hasOwnProperty(oldKeyName)) {
+        throw new Error(`The old key name '${oldKeyName}' does not exist in the 'keys' object.`);
+    }
+    if (values.keys.hasOwnProperty(newKeyName)) {
+        throw new Error(`The new key name '${newKeyName}' already exists in the 'keys' object.`);
+    }
+    // Clone the old key and value properties
+    values.keys[newKeyName] = JSON.parse(JSON.stringify(values.keys[oldKeyName]));
+    values.values[newKeyName] = JSON.parse(JSON.stringify(values.values[oldKeyName]));
+    // Update the type of the new key
+    values.keys[newKeyName].type = JSON.parse(JSON.stringify(type));
+    // Delete the old key and value properties
+    delete values.keys[oldKeyName];
+    delete values.values[oldKeyName];
+    return values;
+}
+export function getSortedValuesByType(values) {
+    const valuesByType = new Map();
+    // There's a possibility that there are no variantsByID. So we prevent errors by using || {}
+    // to return an empty array, breaking out of the loop.
+    let valuesByTypeForKey = [];
+    for (const keyName of Object.keys(values?.keys || {})) {
+        const type = values.keys[keyName].type;
+        for (const uuid of Object.keys(values?.variantsByID || {})) {
+            // Possible for the value to not exist.
+            const value = values.values?.[keyName]?.[uuid];
+            const priority = values.variantsByID[uuid].priority;
+            valuesByTypeForKey.push({
+                value,
+                uuid,
+                priority,
+            });
+        }
+        valuesByTypeForKey.sort((a, b) => a.priority - b.priority);
+        valuesByType.set(keyName, {
+            values: valuesByTypeForKey,
+            type,
+        });
+        valuesByTypeForKey = [];
+    }
+    return valuesByType;
+}
+/**
+ * Given a uuid of an existing variant alongside a direction, shifts the priority of the variant in the direction.
+ * @param values The values to mutate
+ * @param uuid The uuid of the variant to shift
+ * @param direction The direction to shift the variant in
+ * @returns The mutated values
+ * @note The variant must exist in the values.
+ * @note The variant's priority will never be less than 1 as this is reserved for the default variant.
+ * @note the priority of the default variant will never change from 0.
+ */
+export function shiftPriorityLeftOrRightByUUID(values, uuid, direction) {
+    const currentPriority = values.variantsByID[uuid].priority;
+    if (!canShiftPriorityLeftOrRightByUUID(values, uuid, direction))
+        return values;
+    const [higherNeighbourUUID, lowerNeighbourUUID] = [1, -1].map(v => getPriorityNeighbourUUID(values, uuid, v));
+    if (!lowerNeighbourUUID) {
+        throw new Error('No lower neighbour found, this should not happen as default is always at priority 0.');
+    }
+    if (direction === 'left' && values.variantsByID[lowerNeighbourUUID].priority === 0)
+        return values;
+    if (direction === 'left') {
+        values.variantsByID[uuid].priority = values.variantsByID[lowerNeighbourUUID].priority;
+        values.variantsByID[lowerNeighbourUUID].priority = currentPriority;
+    }
+    else {
+        values.variantsByID[uuid].priority = values.variantsByID[higherNeighbourUUID].priority;
+        values.variantsByID[higherNeighbourUUID].priority = currentPriority;
+    }
+    return values;
+}
+/**
+ *
+ * @param values The values to mutate.
+ * @param keyName The key to delete.
+ * @returns The mutated values.
+ */
+export function deleteKeyFromValues(values, keyName) {
+    delete values.keys[keyName];
+    delete values.values[keyName];
+    return values;
+}
+/**
+ *
+ * @param values The values to mutate.
+ * @param uuid The uuid of the variant to shift.
+ * @param direction The direction to shift the variant in.
+ * @returns The mutated values.
+ */
+export function canShiftPriorityLeftOrRightByUUID(values, uuid, direction) {
+    const currentPriority = values.variantsByID[uuid].priority;
+    if (currentPriority === 1 && direction === 'left')
+        return false;
+    if (uuidIsHighestPriority(values, uuid) && direction === 'right')
+        return false;
+    return true;
+}
+/**
+ *
+ * @param values The values to check.
+ * @param uuid The uuid of the variant to check.
+ * @returns Whether the variant is the highest priority variant.
+ */
+function uuidIsHighestPriority(values, uuid) {
+    const variants = values.variantsByID;
+    const priority = variants[uuid].priority;
+    const highestPriority = Object.keys(variants).reduce((highest, v) => {
+        return variants[v].priority > highest ? variants[v].priority : highest;
+    }, 0);
+    return priority === highestPriority;
+}
+/**
+ *
+ * @param values The values to check.
+ * @param uuid The uuid of the variant to check.
+ * @param direction The direction to check.
+ * @returns The uuid of the neighbour variant.
+ */
+function getPriorityNeighbourUUID(values, uuid, direction) {
+    const variants = values.variantsByID;
+    const priority = variants[uuid].priority;
+    const neighbourPriority = priority + direction;
+    const neighbourUUID = Object.keys(variants).find(v => variants[v].priority === neighbourPriority);
+    return neighbourUUID;
+}
+/**
+ *
+ * @param values The values to mutate.
+ * @param value The value to set.
+ * @param key The key to add the value to.
+ * @returns The mutated values.
+ */
+export function setDefaultValueForKey(values, value, key) {
+    if (key === undefined || value === undefined)
+        return values;
+    const defaultUUID = Object.keys(values.variantsByID).find(uuid => values.variantsByID[uuid].priority === 0);
+    if (!defaultUUID) {
+        throw new Error('No default variant found');
+    }
+    values.values[key][defaultUUID] = value;
+    return values;
+}
+/**
+ * Get the default value for a key.
+ * @param values The values to get the default value from.
+ * @param key The key to get the default value for.
+ * @returns The default value for the key, or undefined if no default value is set.
+ */
+export function getDefaultValueForKey(values, key) {
+    const defaultVariantID = Object.keys(values.variantsByID).find(id => values.variantsByID[id].conditionType === ConditionType.Default);
+    const defaultValue = values.values[key]?.[defaultVariantID];
+    return defaultValue;
+}
+/**
+ * Get a set of default values by key.
+ * @param values The values to get the default values from.
+ * @returns The default values by key.
+ */
+export function getDefaultValuesByKey(values) {
+    const defaultValuesByKey = new Map();
+    for (const key of Object.keys(values.keys)) {
+        defaultValuesByKey.set(key, getDefaultValueForKey(values, key));
+    }
+    return defaultValuesByKey;
+}
+/**
+ * @param values The values to parse.
+ * @returns A map of key names to their type representations.
+ */
+export function getTypesByKey(values) {
+    const typesByKey = new Map();
+    for (const key of Object.keys(values.keys)) {
+        typesByKey.set(key, values.keys[key].type);
+    }
+    return typesByKey;
+}
+/**
+ *
+ * @param values The values to check.
+ * @returns Returns a map of key names to their [type representations, default values].
+ */
+export function getTypesAndDefaultsByKey(values) {
+    const typesAndDefaultsByKey = new Map();
+    for (const key of Object.keys(values.keys)) {
+        typesAndDefaultsByKey.set(key, [values.keys[key].type, getDefaultValueForKey(values, key)]);
+    }
+    return typesAndDefaultsByKey;
+}
+/**
+ * Adds a new key to the values.
+ * @param keyname The name of the key.
+ * @param type The type of the key.
+ * @param values The values to add the key to.
+ * @returns The new values.
+ */
+export function addNewKeyToValues(keyname, type, values) {
+    values.keys[keyname] = { type };
+    values.values[keyname] = {};
+    return values;
+}
+/**
+ * Inserts a new key containing a default value into the values.
+ * @param keyname The name of the key.
+ * @param type The type of the key.
+ * @param values The values to add the key to.
+ * @param defaultValue The default value to set for the key.
+ * @returns The new values.
+ */
+export function addNewKeyToValuesWithDefaultValue(keyname, type, values, defaultValue) {
+    const variantWithNewKey = addNewKeyToValues(keyname, type, values);
+    return setDefaultValueForKey(variantWithNewKey, defaultValue, keyname);
+}
+/**
+ * Add a new variant to the values.
+ * @param uuid The uuid of the new variant.
+ * @param variant The variant to add.
+ * @param values The values to add the variant to.
+ * @returns The new values.
+ */
+export function addNewVariantToValues(values, uuid, variant) {
+    const currentHighestPriority = Object.keys(values.variantsByID).reduce((highest, v) => {
+        return values.variantsByID[v].priority > highest ? values.variantsByID[v].priority : highest;
+    }, 0);
+    variant.priority = currentHighestPriority + 1;
+    values.variantsByID[uuid] = variant;
+    return values;
+}
+/**
+ *	Remove a variant from the values
+ * @param uuid The uuid of the variant to remove
+ * @param values The values to remove the variant from
+ * @returns The new values object
+ */
+export function removeVariantFromValuesByUUID(uuid, values) {
+    delete values.variantsByID[uuid];
+    Object.keys(values.values).forEach(key => {
+        delete values.values[key][uuid];
+    });
+    return values;
+}
+/**
+ * Returns a new values object with the value overridden.
+ * @param keyname The keyname of the value to override.
+ * @param variantID The variantID of the value to override.
+ * @param value The new value.
+ * @param values The values object to override.
+ * @returns
+ */
+export function changeValueInValues(keyname, uuid, value, values) {
+    if (value === undefined) {
+        // delete it
+        delete values.values[keyname][uuid];
+    }
+    else {
+        values.values[keyname][uuid] = value;
+    }
+    return values;
+}
+/**
+ * Gets the value for a key in a variant.
+ * @param values The values to check.
+ * @param key The key to get the value for.
+ * @param uuid The uuid of the variant to get the value for.
+ * @returns The value for the key in the variant.
+ */
+function getValueByKeyAndUUID(values, key, uuid) {
+    return values.values[key][uuid];
+}
+/**
+ *  Gets the values for a key.
+ * @param values The values to check.
+ * @param keyName The key to get the value for.
+ * @returns An array of values for the key.
+ */
+function getValuesByKeyname(values, keyName) {
+    const row = new Array(Object.keys(values.variantsByID).length);
+    const sortedUUIDs = getSortedVariantUUIDs(values);
+    sortedUUIDs.forEach((uuid, i) => {
+        let value = getValueByKeyAndUUID(values, keyName, uuid);
+        if (typeof value === 'string' && value.includes(',')) {
+            value = `"${value}"`;
+        }
+        row[i] = value;
+    });
+    return row;
+}
+/**
+ * Gets the sorted uuids of the variants in the values.
+ * @param values The values to check.
+ * @returns A sorted array of uuids.
+ */
+function getSortedVariantUUIDs(values) {
+    const sortedUUIDs = Object.keys(values.variantsByID).sort((a, b) => {
+        const aPriority = values.variantsByID[a].priority;
+        const bPriority = values.variantsByID[b].priority;
+        if (aPriority < bPriority) {
+            return -1;
+        }
+        else if (aPriority > bPriority) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    });
+    return sortedUUIDs;
+}
+/**
+ * Given a values object, returns a CSV string.
+ * @param values The values to convert to CSV.
+ * @returns A CSV string.
+ */
+export function ZValuesToCSVString(values) {
+    let csvString = 'key';
+    const sortedUUIDS = getSortedVariantUUIDs(values);
+    sortedUUIDS.forEach((uuid) => {
+        const variantTitle = variantToString(values.variantsByID[uuid]);
+        csvString += `,${variantTitle}`;
+    });
+    Object.keys(values.keys).forEach((key) => {
+        csvString += `\n${key}`;
+        const row = getValuesByKeyname(values, key);
+        row.forEach((value) => {
+            if (value === undefined)
+                value = '';
+            csvString += `,${value}`;
+        });
+    });
+    return csvString;
+}
+/**
+ * Given a variant object, returns a string.
+ * @param variant The variant to convert to a string.
+ * @returns A string.
+ */
+function variantToString(variant) {
+    switch (variant.conditionType) {
+        case ConditionType.Default:
+            return 'default';
+        case ConditionType.QueryString:
+            return `qs:${variant.param}=${variant.value}`;
+        case ConditionType.UserAgent:
+            return `ua:${variant.agent}`;
+        case ConditionType.Locale:
+            return `locale:${variant.code}`;
+        case ConditionType.Debug:
+            return `debug:${variant.isEnabled}`;
+        default:
+            return 'unknown';
+    }
+}
+function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+    const output = { ...target };
+    for (const key in source) {
+        if (isObject(source[key])) {
+            if (isObject(target[key])) {
+                output[key] = deepMerge(target[key], source[key]);
+            }
+            else {
+                output[key] = deepMerge({}, source[key]);
+            }
+        }
+        else {
+            output[key] = source[key];
+        }
+    }
+    return output;
+}
+/**
+ * Merges a provided csv string into the provided values object.
+ * @param csvString The csv string to merge (source)
+ * @param currentValues The values object to merge into (destination)
+ * @returns The new values object.
+ * @notes This can very likely be improved.
+ * @notes I couldn't quite figure out how to do it in a way that was cleaner than this.
+ */
+export function mergeCSVStringIntoTarget(csvString, currentValues) {
+    // lose the ref
+    currentValues = JSON.parse(JSON.stringify(currentValues));
+    const values = {
+        keys: {},
+        values: {},
+        variantsByID: {},
+    };
+    const lines = csvString.split('\n');
+    const variants = lines[0].split(',');
+    const timestamp = new Date().getTime();
+    // remove "key" from variants
+    variants.shift();
+    // Remove variants from lines
+    lines.shift();
+    // Build the variants
+    variants.forEach((variantString, i) => {
+        const variant = parseStringToVariant(variantString, i);
+        // Nothing happens fast enough to justify a uuid
+        // Most of these are gonna get overwritten.
+        const uuid = i + timestamp.toString();
+        values.variantsByID[uuid] = variant;
+        return parseStringToVariant(variantString, i);
+    });
+    // Build the values
+    lines.forEach((line, i) => {
+        // Split, but ignore commas in quotes
+        const [keyname, ..._values] = line.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/);
+        values.values[keyname] = {};
+        _values.forEach((value, i) => {
+            if (value.length === 0)
+                return;
+            const uuid = i + timestamp.toString();
+            values.values[keyname][uuid] = value;
+        });
+    });
+    // Currently typeinfo is not being saved in the csv as
+    // I could not figure out a clean way to present it.
+    Object.keys(values.values).forEach(key => {
+        values.keys[key] = {
+            type: {
+                name: 'string',
+            },
+        };
+    });
+    // merge values with currentValues
+    // Figure out what UUID of currentValues maps to what UUID of values
+    const lookup = new Map();
+    Object.keys(currentValues.variantsByID).forEach(uuid => {
+        Object.keys(values.variantsByID).forEach(tempUUID => {
+            // Check if content matches
+            if (variantToString(currentValues.variantsByID[uuid]) === variantToString(values.variantsByID[tempUUID])) {
+                lookup.set(tempUUID, uuid);
+            }
+        });
+    });
+    lookup.forEach((uuid, tempUUID) => {
+        // change keys of variantsByID
+        if (values.variantsByID[tempUUID]) {
+            values.variantsByID[uuid] = values.variantsByID[tempUUID];
+            delete values.variantsByID[tempUUID];
+        }
+        // Change keys of values
+        Object.keys(values.values).forEach(key => {
+            // Avoid adding any unexisting values
+            if (values.values[key][tempUUID]) {
+                values.values[key][uuid] = values.values[key][tempUUID];
+                delete values.values[key][tempUUID];
+            }
+        });
+    });
+    // At this stage the two values objects can be merged.
+    // Any matching UUIDS will be overwritten with the incoming values
+    // And any non-existing keys/uuids will be added.
+    // TODO: Post merge structure validation,
+    // returning an error to the user if the structure is invalid.
+    // Attempt to not lose ref
+    // return _.assign({}, _.merge(currentValues, values));
+    return deepMerge(currentValues, values);
+}
+/**
+ *  Given a string, returns a variant object.
+ * @param str The string to convert to a variant.
+ * @param priority The priority of the variant.
+ * @returns A variant object.
+ */
+function parseStringToVariant(str, priority) {
+    const [param, ...value] = str.split(':');
+    switch (param) {
+        case 'qs':
+            const qsVariant = {
+                conditionType: ConditionType.QueryString,
+                param: value[0].split('=')[0],
+                value: value[0].split('=')[1],
+                priority,
+            };
+            return qsVariant;
+        case 'ua':
+            const uaVariant = {
+                conditionType: ConditionType.UserAgent,
+                agent: value[0],
+                priority,
+            };
+            return uaVariant;
+        case 'locale':
+            const localeVariant = {
+                conditionType: ConditionType.Locale,
+                code: value[0],
+                priority,
+            };
+            return localeVariant;
+        case 'debug':
+            const debugVariant = {
+                conditionType: ConditionType.Debug,
+                isEnabled: value[0] === 'true',
+                priority,
+            };
+            return debugVariant;
+        case 'default': {
+            const defaultVariant = {
+                conditionType: ConditionType.Default,
+                priority,
+            };
+            return defaultVariant;
+        }
+        // TODO: This error should be fed back to the user.
+        default:
+            throw new Error(`Unknown variant type: ${param}`);
+            break;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zcomponent/core",
-  "version": "0.0.31-beta",
+  "version": "0.1.0-beta",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,10 +28,8 @@
   "license": "Proprietary",
   "devDependencies": {
     "@playwright/test": "^1.25.0",
-    "@types/ua-parser-js": "^0.7.36",
     "parcel": "^2.8.2",
-    "typescript": "^4.9.4",
-    "ua-parser-js": "^1.0.33"
+    "typescript": "^4.9.4"
   },
   "zexports": [
     "./lib/components/**/*",