onejs-core 3.0.3 → 3.0.4

package/dist/math/index.d.ts

@@ -0,0 +1,86 @@
+/// <reference path="../../definitions/modules.d.ts" />
+import { Matrix4x4, Quaternion, Vector2, Vector2Int, Vector3, Vector3Int, Vector4, Color } from "UnityEngine";
+type CSArray = CS.System.Array;
+export declare function vec2(x: number, y: number): Vector2;
+export declare function vec2i(x: number, y: number): Vector2Int;
+export declare function vec3(x: number, y: number, z: number): Vector3;
+export declare function vec3i(x: number, y: number, z: number): Vector3Int;
+export declare function vec4(x: number, y: number, z: number, w: number): Vector4;
+export declare function quat(): Quaternion;
+export declare function quat(x: number, y: number, z: number, w: number): Quaternion;
+export declare function euler(x: number, y: number, z: number): Quaternion;
+export declare function mat4x4(): Matrix4x4;
+export declare function mat4x4(a: Vector4, b: Vector4, c: Vector4, d: Vector4): Matrix4x4;
+export declare function mat4x4(a: number[][]): Matrix4x4;
+export declare function trs(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4x4;
+export declare function floatArray(...items: number[]): CSArray;
+export declare function vec2Array(...items: number[][]): CSArray;
+export declare function vec2iArray(...items: number[][]): CSArray;
+export declare function vec3Array(...items: number[][]): CSArray;
+export declare function vec3iArray(...items: number[][]): CSArray;
+export declare function vec4Array(...items: number[][]): CSArray;
+export declare function add(a: Vector2, b: Vector2): Vector2;
+export declare function add(a: Vector3, b: Vector3): Vector3;
+export declare function add(a: Vector2Int, b: Vector2Int): Vector2Int;
+export declare function add(a: Vector3Int, b: Vector3Int): Vector3Int;
+export declare function add(a: Vector4, b: Vector4): Vector4;
+export declare function sub(a: Vector2, b: Vector2): Vector2;
+export declare function sub(a: Vector3, b: Vector3): Vector3;
+export declare function sub(a: Vector2Int, b: Vector2Int): Vector2Int;
+export declare function sub(a: Vector3Int, b: Vector3Int): Vector3Int;
+export declare function sub(a: Vector4, b: Vector4): Vector4;
+export declare function neg(a: Vector2): Vector2;
+export declare function neg(a: Vector3): Vector3;
+export declare function neg(a: Vector2Int): Vector2Int;
+export declare function neg(a: Vector3Int): Vector3Int;
+export declare function neg(a: Vector4): Vector4;
+export declare function mul(a: Vector2, b: number): Vector2;
+export declare function mul(a: number, b: Vector2): Vector3;
+export declare function mul(a: Vector3, b: number): Vector3;
+export declare function mul(a: number, b: Vector3): Vector3;
+export declare function mul(a: Vector2Int, b: number): Vector2Int;
+export declare function mul(a: number, b: Vector2Int): Vector2Int;
+export declare function mul(a: Vector3Int, b: number): Vector3Int;
+export declare function mul(a: number, b: Vector3Int): Vector3Int;
+export declare function mul(a: Vector4, b: number): Vector4;
+export declare function mul(a: number, b: Vector4): Vector4;
+export declare function mul(a: Quaternion, b: Quaternion): Quaternion;
+export declare function mul(a: Quaternion, b: Vector3): Vector3;
+export declare function mul(a: Matrix4x4, b: Matrix4x4): Matrix4x4;
+export declare function mul(a: Matrix4x4, b: Vector4): Vector4;
+export declare function div(a: Vector2, b: number): Vector2;
+export declare function div(a: Vector3, b: number): Vector3;
+export declare function div(a: Vector2Int, b: number): Vector2Int;
+export declare function div(a: Vector3Int, b: number): Vector3Int;
+export declare function eq(a: Vector2, b: Vector2): boolean;
+export declare function eq(a: Vector3, b: Vector3): boolean;
+export declare function eq(a: Vector2Int, b: Vector2Int): boolean;
+export declare function eq(a: Vector3Int, b: Vector3Int): boolean;
+export declare function eq(a: Quaternion, b: Quaternion): boolean;
+export declare function dot(a: Vector2, b: Vector2): number;
+export declare function dot(a: Vector3, b: Vector3): number;
+export declare function dot(a: Vector4, b: Vector4): number;
+export declare function dot(a: Quaternion, b: Quaternion): number;
+export declare function clamp(a: Vector2, min: Vector2, max: Vector2): Vector2;
+export declare function clamp(a: Vector3, min: Vector3, max: Vector3): Vector3;
+export declare function clamp(a: Vector2Int, min: Vector2Int, max: Vector2Int): Vector2Int;
+export declare function clamp(a: Vector3Int, min: Vector3Int, max: Vector3Int): Vector3Int;
+export declare function clamp(a: Vector4, min: Vector4, max: Vector4): Vector4;
+export declare function clamp01(a: Vector2): Vector2;
+export declare function clamp01(a: Vector3): Vector3;
+export declare function clamp01(a: Vector4): Vector4;
+export declare function distance(a: Vector2, b: Vector2): number;
+export declare function distance(a: Vector3, b: Vector3): number;
+export declare function distance(a: Vector2Int, b: Vector2Int): number;
+export declare function distance(a: Vector3Int, b: Vector3Int): number;
+export declare function distance(a: Vector4, b: Vector4): number;
+export declare function normalize(a: Vector2): Vector2;
+export declare function normalize(a: Vector3): Vector3;
+export declare function normalize(a: Vector4): Vector4;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function lerp(a: Vector2, b: Vector2, t: number): Vector2;
+export declare function lerp(a: Vector3, b: Vector3, t: number): Vector3;
+export declare function lerp(a: Vector4, b: Vector4, t: number): Vector4;
+export declare function lerp(a: Quaternion, b: Quaternion, t: number): Quaternion;
+export declare function lerp(a: Color, b: Color, t: number): Color;
+export {};

package/dist/math/index.js

@@ -0,0 +1,361 @@
+import { Matrix4x4, Quaternion, Vector2, Vector2Int, Vector3, Vector3Int, Vector4, Color } from "UnityEngine";
+const getType = CS.OneJS.Utils.TypeUtil.GetType;
+const { $typeof } = puer;
+// MARK: - Vectors
+export function vec2(x, y) {
+    return new Vector2(x, y);
+}
+export function vec2i(x, y) {
+    return new Vector2Int(x, y);
+}
+export function vec3(x, y, z) {
+    return new Vector3(x, y, z);
+}
+export function vec3i(x, y, z) {
+    return new Vector3Int(x, y, z);
+}
+export function vec4(x, y, z, w) {
+    return new Vector4(x, y, z, w);
+}
+export function quat(x, y, z, w) {
+    if (x === undefined && y === undefined && z === undefined && w === undefined) {
+        return Quaternion.identity;
+    }
+    if (x !== undefined && y !== undefined && z !== undefined && w !== undefined) {
+        return new Quaternion(x, y, z, w);
+    }
+    throw new Error("Invalid arguments: either no arguments or exactly four numbers.");
+}
+export function euler(x, y, z) {
+    return Quaternion.Euler(x, y, z);
+}
+export function mat4x4(a, b, c, d) {
+    if (a === undefined && b === undefined && c === undefined && d === undefined) {
+        return Matrix4x4.identity;
+    }
+    if (a instanceof Vector4 && b instanceof Vector4 && c instanceof Vector4 && d instanceof Vector4) {
+        return new Matrix4x4(a, b, c, d);
+    }
+    if (Array.isArray(a) && a.length === 4 && a.every(v => Array.isArray(v) && v.length === 4)) {
+        return new Matrix4x4(vec4(a[0][0], a[0][1], a[0][2], a[0][3]), vec4(a[1][0], a[1][1], a[1][2], a[1][3]), vec4(a[2][0], a[2][1], a[2][2], a[2][3]), vec4(a[3][0], a[3][1], a[3][2], a[3][3]));
+    }
+    throw new Error("Invalid arguments: either no arguments, four Vector4s or a 4x4 array of numbers.");
+}
+export function trs(translation, rotation, scale) {
+    return Matrix4x4.TRS(translation, rotation, scale);
+}
+// MARK: - Arrays
+export function floatArray(...items) {
+    const result = newCsArray(CS.System.Single, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, items[i]);
+    }
+    return result;
+}
+export function vec2Array(...items) {
+    const result = newCsArray(Vector2, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec2(items[i][0], items[i][1]));
+    }
+    return result;
+}
+export function vec2iArray(...items) {
+    const result = newCsArray(Vector2Int, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec2i(items[i][0], items[i][1]));
+    }
+    return result;
+}
+export function vec3Array(...items) {
+    const result = newCsArray(Vector3, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec3(items[i][0], items[i][1], items[i][2]));
+    }
+    return result;
+}
+export function vec3iArray(...items) {
+    const result = newCsArray(Vector3Int, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec3i(items[i][0], items[i][1], items[i][2]));
+    }
+    return result;
+}
+export function vec4Array(...items) {
+    const result = newCsArray(Vector4, items.length);
+    for (let i = 0; i < items.length; i++) {
+        result.set(i, vec4(items[i][0], items[i][1], items[i][2], items[i][3]));
+    }
+    return result;
+}
+export function add(a, b) {
+    function isBothOfType(type) {
+        return getType(a) == $typeof(type) && getType(b) == $typeof(type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.op_Addition(a, b);
+    }
+    else if (isBothOfType(Vector2Int)) {
+        return Vector2Int.op_Addition(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.op_Addition(a, b);
+    }
+    else if (isBothOfType(Vector3Int)) {
+        return Vector3Int.op_Addition(a, b);
+    }
+    else if (isBothOfType(Vector4)) {
+        return Vector4.op_Addition(a, b);
+    }
+    throw new Error("Unsupported types for add operation");
+}
+export function sub(a, b) {
+    function isBothOfType(type) {
+        return getType(a) == $typeof(type) && getType(b) == $typeof(type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.op_Subtraction(a, b);
+    }
+    else if (isBothOfType(Vector2Int)) {
+        return Vector2Int.op_Subtraction(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.op_Subtraction(a, b);
+    }
+    else if (isBothOfType(Vector3Int)) {
+        return Vector3Int.op_Subtraction(a, b);
+    }
+    else if (isBothOfType(Vector4)) {
+        return Vector4.op_Subtraction(a, b);
+    }
+    throw new Error("Unsupported types for sub operation");
+}
+export function neg(a) {
+    if (getType(a) == $typeof(Vector2)) {
+        return Vector2.op_UnaryNegation(a);
+    }
+    else if (getType(a) == $typeof(Vector2Int)) {
+        return Vector2Int.op_UnaryNegation(a);
+    }
+    else if (getType(a) == $typeof(Vector3)) {
+        return Vector3.op_UnaryNegation(a);
+    }
+    else if (getType(a) == $typeof(Vector3Int)) {
+        return Vector3Int.op_UnaryNegation(a);
+    }
+    else if (getType(a) == $typeof(Vector4)) {
+        return Vector4.op_UnaryNegation(a);
+    }
+    throw new Error("Unsupported types for neg operation");
+}
+export function mul(a, b) {
+    if (isOfType(a, Quaternion) && isOfType(b, Quaternion)) {
+        return Quaternion.op_Multiply(a, b);
+    }
+    if (isOfType(a, Quaternion) && isOfType(b, Vector3)) {
+        return Quaternion.op_Multiply(a, b);
+    }
+    if (isOfType(a, Matrix4x4) && isOfType(b, Matrix4x4)) {
+        return Matrix4x4.op_Multiply(a, b);
+    }
+    if (isOfType(a, Matrix4x4) && isOfType(b, Vector4)) {
+        return Matrix4x4.op_Multiply(a, b);
+    }
+    if (typeof b === 'number') {
+        if (getType(a) == $typeof(Vector2)) {
+            return Vector2.op_Multiply(a, b);
+        }
+        else if (getType(a) == $typeof(Vector2Int)) {
+            return Vector2Int.op_Multiply(a, b);
+        }
+        else if (getType(a) == $typeof(Vector3)) {
+            return Vector3.op_Multiply(a, b);
+        }
+        else if (getType(a) == $typeof(Vector3Int)) {
+            return Vector3Int.op_Multiply(a, b);
+        }
+        else if (getType(a) == $typeof(Vector4)) {
+            return Vector4.op_Multiply(a, b);
+        }
+    }
+    else if (typeof a === 'number') {
+        if (getType(b) == $typeof(Vector2)) {
+            return Vector2.op_Multiply(b, a);
+        }
+        else if (getType(b) == $typeof(Vector2Int)) {
+            return Vector2Int.op_Multiply(b, a);
+        }
+        else if (getType(b) == $typeof(Vector3)) {
+            return Vector3.op_Multiply(b, a);
+        }
+        else if (getType(b) == $typeof(Vector3Int)) {
+            return Vector3Int.op_Multiply(b, a);
+        }
+        else if (getType(b) == $typeof(Vector4)) {
+            return Vector4.op_Multiply(b, a);
+        }
+    }
+    throw new Error("Unsupported types for mul operation");
+}
+export function div(a, b) {
+    if (typeof b === 'number') {
+        if (getType(a) == $typeof(Vector2)) {
+            return Vector2.op_Division(a, b);
+        }
+        else if (getType(a) == $typeof(Vector2Int)) {
+            return Vector2Int.op_Division(a, b);
+        }
+        else if (getType(a) == $typeof(Vector3)) {
+            return Vector3.op_Division(a, b);
+        }
+        else if (getType(a) == $typeof(Vector3Int)) {
+            return Vector3Int.op_Division(a, b);
+        }
+    }
+    throw new Error("Unsupported types for div operation");
+}
+export function eq(a, b) {
+    function isBothOfType(type) {
+        return getType(a) == $typeof(type) && getType(b) == $typeof(type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.op_Equality(a, b);
+    }
+    else if (isBothOfType(Vector2Int)) {
+        return Vector2Int.op_Equality(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.op_Equality(a, b);
+    }
+    else if (isBothOfType(Vector3Int)) {
+        return Vector3Int.op_Equality(a, b);
+    }
+    else if (isBothOfType(Quaternion)) {
+        return Quaternion.op_Equality(a, b);
+    }
+    throw new Error("Unsupported types for eq operation");
+}
+export function dot(a, b) {
+    function isBothOfType(type) {
+        return isOfType(a, type) && isOfType(b, type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.Dot(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.Dot(a, b);
+    }
+    else if (isBothOfType(Vector4)) {
+        return Vector4.Dot(a, b);
+    }
+    else if (isBothOfType(Quaternion)) {
+        return Quaternion.Dot(a, b);
+    }
+    throw new Error("Unsupported types for dot operation");
+}
+export function clamp(a, min, max) {
+    function isAllOfType(type) {
+        return isOfType(a, type) && isOfType(min, type) && isOfType(max, type);
+    }
+    if (isAllOfType(Vector2)) {
+        return vec2(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y));
+    }
+    else if (isAllOfType(Vector3)) {
+        return vec3(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y), Math.min(Math.max(a.z, min.z), max.z));
+    }
+    else if (isAllOfType(Vector2Int)) {
+        return vec2i(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y));
+    }
+    else if (isAllOfType(Vector3Int)) {
+        return vec3i(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y), Math.min(Math.max(a.z, min.z), max.z));
+    }
+    else if (isAllOfType(Vector4)) {
+        return vec4(Math.min(Math.max(a.x, min.x), max.x), Math.min(Math.max(a.y, min.y), max.y), Math.min(Math.max(a.z, min.z), max.z), Math.min(Math.max(a.w, min.w), max.w));
+    }
+    throw new Error("Unsupported types for clamp operation");
+}
+export function clamp01(a) {
+    if (isOfType(a, Vector2)) {
+        return vec2(Math.min(Math.max(a.x, 0), 1), Math.min(Math.max(a.y, 0), 1));
+    }
+    else if (isOfType(a, Vector3)) {
+        return vec3(Math.min(Math.max(a.x, 0), 1), Math.min(Math.max(a.y, 0), 1), Math.min(Math.max(a.z, 0), 1));
+    }
+    else if (isOfType(a, Vector4)) {
+        return vec4(Math.min(Math.max(a.x, 0), 1), Math.min(Math.max(a.y, 0), 1), Math.min(Math.max(a.z, 0), 1), Math.min(Math.max(a.w, 0), 1));
+    }
+    throw new Error("Unsupported types for clamp01 operation");
+}
+export function distance(a, b) {
+    function isBothOfType(type) {
+        return isOfType(a, type) && isOfType(b, type);
+    }
+    if (isBothOfType(Vector2)) {
+        return Vector2.Distance(a, b);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.Distance(a, b);
+    }
+    else if (isBothOfType(Vector2Int)) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    else if (isBothOfType(Vector3Int)) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        const dz = a.z - b.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    else if (isBothOfType(Vector4)) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        const dz = a.z - b.z;
+        const dw = a.w - b.w;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz + dw * dw);
+    }
+    throw new Error("Unsupported types for distance operation");
+}
+export function normalize(a) {
+    if (isOfType(a, Vector2)) {
+        const magnitude = Math.sqrt(a.x * a.x + a.y * a.y);
+        if (magnitude < 1e-6) {
+            return vec2(0, 0);
+        }
+        return vec2(a.x / magnitude, a.y / magnitude);
+    }
+    else if (isOfType(a, Vector3)) {
+        return Vector3.Normalize(a);
+    }
+    else if (isOfType(a, Vector4)) {
+        return Vector4.Normalize(a);
+    }
+    throw new Error("Unsupported types for normalize operation");
+}
+export function lerp(a, b, t) {
+    function isBothOfType(type) {
+        return isOfType(a, type) && isOfType(b, type);
+    }
+    if (typeof a === 'number' && typeof b === 'number') {
+        return a + (b - a) * t;
+    }
+    else if (isBothOfType(Vector2)) {
+        return Vector2.Lerp(a, b, t);
+    }
+    else if (isBothOfType(Vector3)) {
+        return Vector3.Lerp(a, b, t);
+    }
+    else if (isBothOfType(Vector4)) {
+        return vec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t);
+    }
+    else if (isBothOfType(Quaternion)) {
+        return Quaternion.Lerp(a, b, t);
+    }
+    else if (isBothOfType(Color)) {
+        return Color.Lerp(a, b, t);
+    }
+    throw new Error("Unsupported types for lerp operation");
+}
+// MARK: - Utilities
+function isOfType(obj, type) {
+    return getType(obj) == $typeof(type);
+}

package/dist/preloads/inject.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="../../definitions/index.d.ts" />
+export declare function btoa(text: string): string;
+export declare function atob(base64: string): string;

package/dist/preloads/inject.js

@@ -0,0 +1,36 @@
+/// <reference path="../definitions/index.d.ts" />
+export function btoa(text) {
+    // return CS.OneJS.CommonGlobals.btoa(text);
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    let str = text;
+    let output = '';
+    for (let i = 0; i < str.length; i += 3) {
+        let block = (str.charCodeAt(i) << 16) | ((i + 1 < str.length ? str.charCodeAt(i + 1) : 0) << 8) | (i + 2 < str.length ? str.charCodeAt(i + 2) : 0);
+        output += chars[(block >> 18) & 0x3F] +
+            chars[(block >> 12) & 0x3F] +
+            (i + 1 < str.length ? chars[(block >> 6) & 0x3F] : '=') +
+            (i + 2 < str.length ? chars[block & 0x3F] : '=');
+    }
+    return output;
+}
+// function uint8ArrayToString(uint8Array) {
+//     const chars: any = [];
+//     for (let i = 0; i < uint8Array.length; i++) {
+//         chars.push(String.fromCharCode(uint8Array[i]));
+//     }
+//     return chars.join('');
+// }
+export function atob(base64) {
+    // return CS.OneJS.CommonGlobals.atob(base64);
+    // return CS.System.Text.Encoding.UTF8.GetString(CS.System.Convert.FromBase64String(base64))
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    let str = base64.replace(/=+$/, '');
+    let output = '';
+    if (str.length % 4 == 1) {
+        throw new Error('Invalid base64 string');
+    }
+    for (let bc = 0, bs = 0, buffer, idx = 0; buffer = str.charAt(idx++); ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
+        buffer = chars.indexOf(buffer);
+    }
+    return output;
+}

package/dist/styling/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference path="../../definitions/index.d.ts" />
+export declare function hashAndAddRuntimeUSS(style: string): string;
+/**
+ * Similar to the Emotion api, this function takes a template string and returns
+ * a class name that can be used to style an element.
+ * @param strings
+ * @param values
+ * @returns
+ */
+export declare const emo: (strings: TemplateStringsArray, ...values: any[]) => string;

package/dist/styling/index.js

@@ -0,0 +1,28 @@
+/// <reference path="../definitions/index.d.ts" />
+import flatten from "css-flatten";
+import generateComponentId from "./utils/generateComponentId";
+const _pastCompIds = new Set();
+export function hashAndAddRuntimeUSS(style) {
+    let compId = generateComponentId(style);
+    if (_pastCompIds.has(compId))
+        return compId;
+    style = `.${compId} {${style}}`;
+    style = flatten(style);
+    globalThis.___document.addRuntimeUSS(style);
+    _pastCompIds.add(compId);
+    return compId;
+}
+/**
+ * Similar to the Emotion api, this function takes a template string and returns
+ * a class name that can be used to style an element.
+ * @param strings
+ * @param values
+ * @returns
+ */
+export const emo = function (strings, ...values) {
+    let style = values.reduce((result, expr, index) => {
+        const value = expr;
+        return result + (value ? value : "") + strings[index + 1];
+    }, strings[0]);
+    return hashAndAddRuntimeUSS(style);
+};

package/dist/styling/utils/generateAlphabeticName.d.ts

@@ -0,0 +1 @@
+export default function generateAlphabeticName(code: number): string;

package/dist/styling/utils/generateAlphabeticName.js

@@ -0,0 +1,16 @@
+const AD_REPLACER_R = /(a)(d)/gi;
+/* This is the "capacity" of our alphabet i.e. 2x26 for all letters plus their capitalised
+ * counterparts */
+const charsLength = 52;
+/* start at 75 for 'a' until 'z' (25) and then start at 65 for capitalised letters */
+const getAlphabeticChar = (code) => String.fromCharCode(code + (code > 25 ? 39 : 97));
+/* input a number, usually a hash and convert it to base-52 */
+export default function generateAlphabeticName(code) {
+    let name = '';
+    let x;
+    /* get a char and divide by alphabet-length */
+    for (x = Math.abs(code); x > charsLength; x = (x / charsLength) | 0) {
+        name = getAlphabeticChar(x % charsLength) + name;
+    }
+    return (getAlphabeticChar(x % charsLength) + name).replace(AD_REPLACER_R, '$1-$2');
+}

package/dist/styling/utils/generateComponentId.d.ts

@@ -0,0 +1 @@
+export default function generateComponentId(str: string): string;

package/dist/styling/utils/generateComponentId.js

@@ -0,0 +1,5 @@
+import generateAlphabeticName from './generateAlphabeticName';
+import { hash } from './hash';
+export default function generateComponentId(str) {
+    return generateAlphabeticName(hash(str) >>> 0);
+}

package/dist/styling/utils/hash.d.ts

@@ -0,0 +1,5 @@
+export declare const SEED = 5381;
+export declare const phash: (h: number, x: string) => number;
+export declare const hash: (x: string) => number;
+export declare function generateAlphabeticName(code: number): string;
+export default function generateComponentId(str: string): string;

package/dist/styling/utils/hash.js

@@ -0,0 +1,34 @@
+export const SEED = 5381;
+// When we have separate strings it's useful to run a progressive
+// version of djb2 where we pretend that we're still looping over
+// the same string
+export const phash = (h, x) => {
+    let i = x.length;
+    while (i) {
+        h = (h * 33) ^ x.charCodeAt(--i);
+    }
+    return h;
+};
+// This is a djb2 hashing function
+export const hash = (x) => {
+    return phash(SEED, x);
+};
+const AD_REPLACER_R = /(a)(d)/gi;
+/* This is the "capacity" of our alphabet i.e. 2x26 for all letters plus their capitalised
+ * counterparts */
+const charsLength = 52;
+/* start at 75 for 'a' until 'z' (25) and then start at 65 for capitalised letters */
+const getAlphabeticChar = (code) => String.fromCharCode(code + (code > 25 ? 39 : 97));
+/* input a number, usually a hash and convert it to base-52 */
+export function generateAlphabeticName(code) {
+    let name = '';
+    let x;
+    /* get a char and divide by alphabet-length */
+    for (x = Math.abs(code); x > charsLength; x = (x / charsLength) | 0) {
+        name = getAlphabeticChar(x % charsLength) + name;
+    }
+    return (getAlphabeticChar(x % charsLength) + name).replace(AD_REPLACER_R, '$1-$2');
+}
+export default function generateComponentId(str) {
+    return generateAlphabeticName(hash(str) >>> 0);
+}

package/dist/utils/arrays.d.ts

@@ -0,0 +1 @@
+export declare function toJsArray<T>(csArr: any): T[];

package/dist/utils/arrays.js

@@ -0,0 +1,10 @@
+export function toJsArray(csArr) {
+    if (!csArr)
+        return [];
+    let arr = new Array(csArr.Length);
+    var i = csArr.Length;
+    while (i--) {
+        arr[i] = csArr.get_Item(i);
+    }
+    return arr;
+}

package/dist/utils/color-palettes.d.ts

@@ -0,0 +1,2 @@
+declare let palettes: string[][];
+export { palettes };

package/dist/utils/color-palettes.js

@@ -0,0 +1,2 @@
+let palettes = [["#69d2e7", "#a7dbd8", "#e0e4cc", "#f38630", "#fa6900"], ["#fe4365", "#fc9d9a", "#f9cdad", "#c8c8a9", "#83af9b"], ["#ecd078", "#d95b43", "#c02942", "#542437", "#53777a"], ["#556270", "#4ecdc4", "#c7f464", "#ff6b6b", "#c44d58"], ["#774f38", "#e08e79", "#f1d4af", "#ece5ce", "#c5e0dc"], ["#e8ddcb", "#cdb380", "#036564", "#033649", "#031634"], ["#490a3d", "#bd1550", "#e97f02", "#f8ca00", "#8a9b0f"], ["#594f4f", "#547980", "#45ada8", "#9de0ad", "#e5fcc2"], ["#00a0b0", "#6a4a3c", "#cc333f", "#eb6841", "#edc951"], ["#e94e77", "#d68189", "#c6a49a", "#c6e5d9", "#f4ead5"], ["#3fb8af", "#7fc7af", "#dad8a7", "#ff9e9d", "#ff3d7f"], ["#d9ceb2", "#948c75", "#d5ded9", "#7a6a53", "#99b2b7"], ["#ffffff", "#cbe86b", "#f2e9e1", "#1c140d", "#cbe86b"], ["#efffcd", "#dce9be", "#555152", "#2e2633", "#99173c"], ["#343838", "#005f6b", "#008c9e", "#00b4cc", "#00dffc"], ["#413e4a", "#73626e", "#b38184", "#f0b49e", "#f7e4be"], ["#ff4e50", "#fc913a", "#f9d423", "#ede574", "#e1f5c4"], ["#99b898", "#fecea8", "#ff847c", "#e84a5f", "#2a363b"], ["#655643", "#80bca3", "#f6f7bd", "#e6ac27", "#bf4d28"], ["#00a8c6", "#40c0cb", "#f9f2e7", "#aee239", "#8fbe00"], ["#351330", "#424254", "#64908a", "#e8caa4", "#cc2a41"], ["#554236", "#f77825", "#d3ce3d", "#f1efa5", "#60b99a"], ["#5d4157", "#838689", "#a8caba", "#cad7b2", "#ebe3aa"], ["#8c2318", "#5e8c6a", "#88a65e", "#bfb35a", "#f2c45a"], ["#fad089", "#ff9c5b", "#f5634a", "#ed303c", "#3b8183"], ["#ff4242", "#f4fad2", "#d4ee5e", "#e1edb9", "#f0f2eb"], ["#f8b195", "#f67280", "#c06c84", "#6c5b7b", "#355c7d"], ["#d1e751", "#ffffff", "#000000", "#4dbce9", "#26ade4"], ["#1b676b", "#519548", "#88c425", "#bef202", "#eafde6"], ["#5e412f", "#fcebb6", "#78c0a8", "#f07818", "#f0a830"], ["#bcbdac", "#cfbe27", "#f27435", "#f02475", "#3b2d38"], ["#452632", "#91204d", "#e4844a", "#e8bf56", "#e2f7ce"], ["#eee6ab", "#c5bc8e", "#696758", "#45484b", "#36393b"], ["#f0d8a8", "#3d1c00", "#86b8b1", "#f2d694", "#fa2a00"], ["#2a044a", "#0b2e59", "#0d6759", "#7ab317", "#a0c55f"], ["#f04155", "#ff823a", "#f2f26f", "#fff7bd", "#95cfb7"], ["#b9d7d9", "#668284", "#2a2829", "#493736", "#7b3b3b"], ["#bbbb88", "#ccc68d", "#eedd99", "#eec290", "#eeaa88"], ["#b3cc57", "#ecf081", "#ffbe40", "#ef746f", "#ab3e5b"], ["#a3a948", "#edb92e", "#f85931", "#ce1836", "#009989"], ["#300030", "#480048", "#601848", "#c04848", "#f07241"], ["#67917a", "#170409", "#b8af03", "#ccbf82", "#e33258"], ["#aab3ab", "#c4cbb7", "#ebefc9", "#eee0b7", "#e8caaf"], ["#e8d5b7", "#0e2430", "#fc3a51", "#f5b349", "#e8d5b9"], ["#ab526b", "#bca297", "#c5ceae", "#f0e2a4", "#f4ebc3"], ["#607848", "#789048", "#c0d860", "#f0f0d8", "#604848"], ["#b6d8c0", "#c8d9bf", "#dadabd", "#ecdbbc", "#fedcba"], ["#a8e6ce", "#dcedc2", "#ffd3b5", "#ffaaa6", "#ff8c94"], ["#3e4147", "#fffedf", "#dfba69", "#5a2e2e", "#2a2c31"], ["#fc354c", "#29221f", "#13747d", "#0abfbc", "#fcf7c5"], ["#cc0c39", "#e6781e", "#c8cf02", "#f8fcc1", "#1693a7"], ["#1c2130", "#028f76", "#b3e099", "#ffeaad", "#d14334"], ["#a7c5bd", "#e5ddcb", "#eb7b59", "#cf4647", "#524656"], ["#dad6ca", "#1bb0ce", "#4f8699", "#6a5e72", "#563444"], ["#5c323e", "#a82743", "#e15e32", "#c0d23e", "#e5f04c"], ["#edebe6", "#d6e1c7", "#94c7b6", "#403b33", "#d3643b"], ["#fdf1cc", "#c6d6b8", "#987f69", "#e3ad40", "#fcd036"], ["#230f2b", "#f21d41", "#ebebbc", "#bce3c5", "#82b3ae"], ["#b9d3b0", "#81bda4", "#b28774", "#f88f79", "#f6aa93"], ["#3a111c", "#574951", "#83988e", "#bcdea5", "#e6f9bc"], ["#5e3929", "#cd8c52", "#b7d1a3", "#dee8be", "#fcf7d3"], ["#1c0113", "#6b0103", "#a30006", "#c21a01", "#f03c02"], ["#000000", "#9f111b", "#b11623", "#292c37", "#cccccc"], ["#382f32", "#ffeaf2", "#fcd9e5", "#fbc5d8", "#f1396d"], ["#e3dfba", "#c8d6bf", "#93ccc6", "#6cbdb5", "#1a1f1e"], ["#f6f6f6", "#e8e8e8", "#333333", "#990100", "#b90504"], ["#1b325f", "#9cc4e4", "#e9f2f9", "#3a89c9", "#f26c4f"], ["#a1dbb2", "#fee5ad", "#faca66", "#f7a541", "#f45d4c"], ["#c1b398", "#605951", "#fbeec2", "#61a6ab", "#accec0"], ["#5e9fa3", "#dcd1b4", "#fab87f", "#f87e7b", "#b05574"], ["#951f2b", "#f5f4d7", "#e0dfb1", "#a5a36c", "#535233"], ["#8dccad", "#988864", "#fea6a2", "#f9d6ac", "#ffe9af"], ["#2d2d29", "#215a6d", "#3ca2a2", "#92c7a3", "#dfece6"], ["#413d3d", "#040004", "#c8ff00", "#fa023c", "#4b000f"], ["#eff3cd", "#b2d5ba", "#61ada0", "#248f8d", "#605063"], ["#ffefd3", "#fffee4", "#d0ecea", "#9fd6d2", "#8b7a5e"], ["#cfffdd", "#b4dec1", "#5c5863", "#a85163", "#ff1f4c"], ["#9dc9ac", "#fffec7", "#f56218", "#ff9d2e", "#919167"], ["#4e395d", "#827085", "#8ebe94", "#ccfc8e", "#dc5b3e"], ["#a8a7a7", "#cc527a", "#e8175d", "#474747", "#363636"], ["#f8edd1", "#d88a8a", "#474843", "#9d9d93", "#c5cfc6"], ["#046d8b", "#309292", "#2fb8ac", "#93a42a", "#ecbe13"], ["#f38a8a", "#55443d", "#a0cab5", "#cde9ca", "#f1edd0"], ["#a70267", "#f10c49", "#fb6b41", "#f6d86b", "#339194"], ["#ff003c", "#ff8a00", "#fabe28", "#88c100", "#00c176"], ["#ffedbf", "#f7803c", "#f54828", "#2e0d23", "#f8e4c1"], ["#4e4d4a", "#353432", "#94ba65", "#2790b0", "#2b4e72"], ["#0ca5b0", "#4e3f30", "#fefeeb", "#f8f4e4", "#a5b3aa"], ["#4d3b3b", "#de6262", "#ffb88c", "#ffd0b3", "#f5e0d3"], ["#fffbb7", "#a6f6af", "#66b6ab", "#5b7c8d", "#4f2958"], ["#edf6ee", "#d1c089", "#b3204d", "#412e28", "#151101"], ["#9d7e79", "#ccac95", "#9a947c", "#748b83", "#5b756c"], ["#fcfef5", "#e9ffe1", "#cdcfb7", "#d6e6c3", "#fafbe3"], ["#9cddc8", "#bfd8ad", "#ddd9ab", "#f7af63", "#633d2e"], ["#30261c", "#403831", "#36544f", "#1f5f61", "#0b8185"], ["#aaff00", "#ffaa00", "#ff00aa", "#aa00ff", "#00aaff"], ["#d1313d", "#e5625c", "#f9bf76", "#8eb2c5", "#615375"], ["#ffe181", "#eee9e5", "#fad3b2", "#ffba7f", "#ff9c97"], ["#73c8a9", "#dee1b6", "#e1b866", "#bd5532", "#373b44"], ["#805841", "#dcf7f3", "#fffcdd", "#ffd8d8", "#f5a2a2"]];
+export { palettes };