fable-compiler
Version:
Fable compiler
686 lines • 19.8 kB
JavaScript
// tslint:disable:ban-types
export function bindThis(this$, source) {
for (const key of Object.keys(source)) {
if (typeof source[key] === "function") {
source[key] = source[key].bind(this$);
}
}
return source;
}
// Object.assign flattens getters and setters
// See https://stackoverflow.com/questions/37054596/js-es5-how-to-assign-objects-with-setters-and-getters
export function extend(target, ...sources) {
for (const source of sources) {
for (const key of Object.keys(source)) {
const descr = Object.getOwnPropertyDescriptor(source, key);
if (descr) {
Object.defineProperty(target, key, descr);
}
}
}
return target;
}
export function isIterable(x) {
return x != null && typeof x === "object" && Symbol.iterator in x;
}
export function isArrayLike(x) {
return x != null && (Array.isArray(x) || ArrayBuffer.isView(x));
}
export function isComparer(x) {
return x != null && typeof x.Compare === "function";
}
export function isComparable(x) {
return x != null && typeof x.CompareTo === "function";
}
export function isEquatable(x) {
return x != null && typeof x.Equals === "function";
}
export function isHashable(x) {
return x != null && typeof x.GetHashCode === "function";
}
export function isDisposable(x) {
return x != null && typeof x.Dispose === "function";
}
export class Comparer {
constructor(f) {
this.Compare = f || compare;
}
}
export function comparerFromEqualityComparer(comparer) {
// Sometimes IEqualityComparer also implements IComparer
if (isComparer(comparer)) {
return new Comparer(comparer.Compare);
}
else {
return new Comparer((x, y) => {
const xhash = comparer.GetHashCode(x);
const yhash = comparer.GetHashCode(y);
if (xhash === yhash) {
return comparer.Equals(x, y) ? 0 : -1;
}
else {
return xhash < yhash ? -1 : 1;
}
});
}
}
// TODO: Move these three methods to Map and Set modules
export function containsValue(v, map) {
for (const kv of map) {
if (equals(v, kv[1])) {
return true;
}
}
return false;
}
export function tryGetValue(map, key, defaultValue) {
return map.has(key) ? [true, map.get(key)] : [false, defaultValue];
}
export function addToSet(v, set) {
if (set.has(v)) {
return false;
}
set.add(v);
return true;
}
export function assertEqual(actual, expected, msg) {
if (!equals(actual, expected)) {
throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {
actual,
expected,
});
}
}
export function assertNotEqual(actual, expected, msg) {
if (equals(actual, expected)) {
throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {
actual,
expected,
});
}
}
export class Lazy {
constructor(factory) {
this.factory = factory;
this.isValueCreated = false;
}
get Value() {
if (!this.isValueCreated) {
this.createdValue = this.factory();
this.isValueCreated = true;
}
return this.createdValue;
}
get IsValueCreated() {
return this.isValueCreated;
}
}
export function lazyFromValue(v) {
return new Lazy(() => v);
}
export function padWithZeros(i, length) {
let str = i.toString(10);
while (str.length < length) {
str = "0" + str;
}
return str;
}
export function padLeftAndRightWithZeros(i, lengthLeft, lengthRight) {
let str = i.toString(10);
while (str.length < lengthLeft) {
str = "0" + str;
}
while (str.length < lengthRight) {
str = str + "0";
}
return str;
}
export function dateOffset(date) {
const date1 = date;
return typeof date1.offset === "number"
? date1.offset
: (date.kind === 1 /* UTC */
? 0 : date.getTimezoneOffset() * -60000);
}
export function int16ToString(i, radix) {
i = i < 0 && radix != null && radix !== 10 ? 0xFFFF + i + 1 : i;
return i.toString(radix);
}
export function int32ToString(i, radix) {
i = i < 0 && radix != null && radix !== 10 ? 0xFFFFFFFF + i + 1 : i;
return i.toString(radix);
}
let ObjectRef = /** @class */ (() => {
class ObjectRef {
static id(o) {
if (!ObjectRef.idMap.has(o)) {
ObjectRef.idMap.set(o, ++ObjectRef.count);
}
return ObjectRef.idMap.get(o);
}
}
ObjectRef.idMap = new WeakMap();
ObjectRef.count = 0;
return ObjectRef;
})();
export { ObjectRef };
export function stringHash(s) {
let i = 0;
let h = 5381;
const len = s.length;
while (i < len) {
h = (h * 33) ^ s.charCodeAt(i++);
}
return h;
}
export function numberHash(x) {
return x * 2654435761 | 0;
}
// From https://stackoverflow.com/a/37449594
export function combineHashCodes(hashes) {
if (hashes.length === 0) {
return 0;
}
return hashes.reduce((h1, h2) => {
return ((h1 << 5) + h1) ^ h2;
});
}
export function identityHash(x) {
if (x == null) {
return 0;
}
switch (typeof x) {
case "boolean":
return x ? 1 : 0;
case "number":
return numberHash(x);
case "string":
return stringHash(x);
default:
return numberHash(ObjectRef.id(x));
}
}
export function structuralHash(x) {
if (x == null) {
return 0;
}
switch (typeof x) {
case "boolean":
return x ? 1 : 0;
case "number":
return numberHash(x);
case "string":
return stringHash(x);
default: {
if (isHashable(x)) {
return x.GetHashCode();
}
else if (isArrayLike(x)) {
const len = x.length;
const hashes = new Array(len);
for (let i = 0; i < len; i++) {
hashes[i] = structuralHash(x[i]);
}
return combineHashCodes(hashes);
}
else {
return stringHash(String(x));
}
}
}
}
export function equalArraysWith(x, y, eq) {
if (x == null) {
return y == null;
}
if (y == null) {
return false;
}
if (x.length !== y.length) {
return false;
}
for (let i = 0; i < x.length; i++) {
if (!eq(x[i], y[i])) {
return false;
}
}
return true;
}
export function equalArrays(x, y) {
return equalArraysWith(x, y, equals);
}
// export function equalObjects(x: { [k: string]: any }, y: { [k: string]: any }): boolean {
// if (x == null) { return y == null; }
// if (y == null) { return false; }
// const xKeys = Object.keys(x);
// const yKeys = Object.keys(y);
// if (xKeys.length !== yKeys.length) {
// return false;
// }
// xKeys.sort();
// yKeys.sort();
// for (let i = 0; i < xKeys.length; i++) {
// if (xKeys[i] !== yKeys[i] || !equals(x[xKeys[i]], y[yKeys[i]])) {
// return false;
// }
// }
// return true;
// }
export function equals(x, y) {
if (x === y) {
return true;
}
else if (x == null) {
return y == null;
}
else if (y == null) {
return false;
}
else if (typeof x !== "object") {
return false;
}
else if (isEquatable(x)) {
return x.Equals(y);
}
else if (isArrayLike(x)) {
return isArrayLike(y) && equalArrays(x, y);
}
else if (x instanceof Date) {
return (y instanceof Date) && compareDates(x, y) === 0;
}
else {
return false;
}
}
export function compareDates(x, y) {
let xtime;
let ytime;
// DateTimeOffset and DateTime deals with equality differently.
if ("offset" in x && "offset" in y) {
xtime = x.getTime();
ytime = y.getTime();
}
else {
xtime = x.getTime() + dateOffset(x);
ytime = y.getTime() + dateOffset(y);
}
return xtime === ytime ? 0 : (xtime < ytime ? -1 : 1);
}
export function comparePrimitives(x, y) {
return x === y ? 0 : (x < y ? -1 : 1);
}
export function compareArraysWith(x, y, comp) {
if (x == null) {
return y == null ? 0 : 1;
}
if (y == null) {
return -1;
}
if (x.length !== y.length) {
return x.length < y.length ? -1 : 1;
}
for (let i = 0, j = 0; i < x.length; i++) {
j = comp(x[i], y[i]);
if (j !== 0) {
return j;
}
}
return 0;
}
export function compareArrays(x, y) {
return compareArraysWith(x, y, compare);
}
export function compareObjects(x, y) {
if (x == null) {
return y == null ? 0 : 1;
}
if (y == null) {
return -1;
}
const xKeys = Object.keys(x);
const yKeys = Object.keys(y);
if (xKeys.length !== yKeys.length) {
return xKeys.length < yKeys.length ? -1 : 1;
}
xKeys.sort();
yKeys.sort();
for (let i = 0, j = 0; i < xKeys.length; i++) {
const key = xKeys[i];
if (key !== yKeys[i]) {
return key < yKeys[i] ? -1 : 1;
}
else {
j = compare(x[key], y[key]);
if (j !== 0) {
return j;
}
}
}
return 0;
}
export function compare(x, y) {
if (x === y) {
return 0;
}
else if (x == null) {
return y == null ? 0 : -1;
}
else if (y == null) {
return 1;
}
else if (typeof x !== "object") {
return x < y ? -1 : 1;
}
else if (isComparable(x)) {
return x.CompareTo(y);
}
else if (isArrayLike(x) && isArrayLike(y)) {
return compareArrays(x, y);
}
else if (x instanceof Date && y instanceof Date) {
return compareDates(x, y);
}
else {
return 1;
}
}
export function min(comparer, x, y) {
return comparer(x, y) < 0 ? x : y;
}
export function max(comparer, x, y) {
return comparer(x, y) > 0 ? x : y;
}
export function createAtom(value) {
let atom = value;
return (value, isSetter) => {
if (!isSetter) {
return atom;
}
else {
atom = value;
return void 0;
}
};
}
const CaseRules = {
None: 0,
LowerFirst: 1,
SnakeCase: 2,
SnakeCaseAllCaps: 3,
KebabCase: 4,
};
function dashify(str, separator) {
return str.replace(/[a-z]?[A-Z]/g, (m) => m.length === 1
? m.toLowerCase()
: m.charAt(0) + separator + m.charAt(1).toLowerCase());
}
function changeCase(str, caseRule) {
switch (caseRule) {
case CaseRules.LowerFirst:
return str.charAt(0).toLowerCase() + str.slice(1);
case CaseRules.SnakeCase:
return dashify(str, "_");
case CaseRules.SnakeCaseAllCaps:
return dashify(str, "_").toUpperCase();
case CaseRules.KebabCase:
return dashify(str, "-");
case CaseRules.None:
default:
return str;
}
}
export function createObj(fields, caseRule = CaseRules.None) {
function fail(kvPair) {
throw new Error("Cannot infer key and value of " + String(kvPair));
}
const o = {};
const definedCaseRule = caseRule;
for (let kvPair of fields) {
let caseRule = CaseRules.None;
if (kvPair == null) {
fail(kvPair);
}
// Deflate unions and use the defined case rule
if (typeof kvPair.toJSON === "function") {
kvPair = kvPair.toJSON();
caseRule = definedCaseRule;
}
if (Array.isArray(kvPair)) {
switch (kvPair.length) {
case 0:
fail(kvPair);
break;
case 1:
o[changeCase(kvPair[0], caseRule)] = true;
break;
case 2:
const value = kvPair[1];
o[changeCase(kvPair[0], caseRule)] = value;
break;
default:
o[changeCase(kvPair[0], caseRule)] = kvPair.slice(1);
}
}
else if (typeof kvPair === "string") {
o[changeCase(kvPair, caseRule)] = true;
}
else {
fail(kvPair);
}
}
return o;
}
export function jsOptions(mutator) {
const opts = {};
mutator(opts);
return opts;
}
export function round(value, digits = 0) {
const m = Math.pow(10, digits);
const n = +(digits ? value * m : value).toFixed(8);
const i = Math.floor(n);
const f = n - i;
const e = 1e-8;
const r = (f > 0.5 - e && f < 0.5 + e) ? ((i % 2 === 0) ? i : i + 1) : Math.round(n);
return digits ? r / m : r;
}
export function sign(x) {
return x > 0 ? 1 : x < 0 ? -1 : 0;
}
export function randomNext(min, max) {
return Math.floor(Math.random() * (max - min)) + min;
}
export function randomBytes(buffer) {
if (buffer == null) {
throw new Error("Buffer cannot be null");
}
for (let i = 0; i < buffer.length; i += 6) {
// Pick random 48-bit number. Fill buffer in 2 24-bit chunks to avoid bitwise truncation.
let r = Math.floor(Math.random() * 281474976710656); // Low 24 bits = chunk 1.
const rhi = Math.floor(r / 16777216); // High 24 bits shifted via division = chunk 2.
for (let j = 0; j < 6 && i + j < buffer.length; j++) {
if (j === 3) {
r = rhi;
}
buffer[i + j] = r & 255;
r >>>= 8;
}
}
}
export function unescapeDataString(s) {
// https://stackoverflow.com/a/4458580/524236
return decodeURIComponent((s).replace(/\+/g, "%20"));
}
export function escapeDataString(s) {
return encodeURIComponent(s).replace(/!/g, "%21")
.replace(/'/g, "%27")
.replace(/\(/g, "%28")
.replace(/\)/g, "%29")
.replace(/\*/g, "%2A");
}
export function escapeUriString(s) {
return encodeURI(s);
}
// ICollection.Clear and Count members can be called on Arrays
// or Dictionaries so we need a runtime check (see #1120)
export function count(col) {
if (isArrayLike(col)) {
return col.length;
}
else {
let count = 0;
for (const _ of col) {
count++;
}
return count;
}
}
export function clear(col) {
if (isArrayLike(col)) {
col.splice(0);
}
else {
col.clear();
}
}
const CURRIED_KEY = "__CURRIED__";
export function uncurry(arity, f) {
// f may be a function option with None value
if (f == null) {
return undefined;
}
// The function is already uncurried
if (f.length > 1) {
// if (CURRIED_KEY in f) { // This doesn't always work
return f;
}
let uncurriedFn;
switch (arity) {
case 2:
uncurriedFn = (a1, a2) => f(a1)(a2);
break;
case 3:
uncurriedFn = (a1, a2, a3) => f(a1)(a2)(a3);
break;
case 4:
uncurriedFn = (a1, a2, a3, a4) => f(a1)(a2)(a3)(a4);
break;
case 5:
uncurriedFn = (a1, a2, a3, a4, a5) => f(a1)(a2)(a3)(a4)(a5);
break;
case 6:
uncurriedFn = (a1, a2, a3, a4, a5, a6) => f(a1)(a2)(a3)(a4)(a5)(a6);
break;
case 7:
uncurriedFn = (a1, a2, a3, a4, a5, a6, a7) => f(a1)(a2)(a3)(a4)(a5)(a6)(a7);
break;
case 8:
uncurriedFn = (a1, a2, a3, a4, a5, a6, a7, a8) => f(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8);
break;
default:
throw new Error("Uncurrying to more than 8-arity is not supported: " + arity);
}
uncurriedFn[CURRIED_KEY] = f;
return uncurriedFn;
}
export function curry(arity, f) {
if (f == null) {
return undefined;
}
if (CURRIED_KEY in f) {
return f[CURRIED_KEY];
}
switch (arity) {
case 2:
return (a1) => (a2) => f(a1, a2);
case 3:
return (a1) => (a2) => (a3) => f(a1, a2, a3);
case 4:
return (a1) => (a2) => (a3) => (a4) => f(a1, a2, a3, a4);
case 5:
return (a1) => (a2) => (a3) => (a4) => (a5) => f(a1, a2, a3, a4, a5);
case 6:
return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => f(a1, a2, a3, a4, a5, a6);
case 7:
return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => f(a1, a2, a3, a4, a5, a6, a7);
case 8:
return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => (a8) => f(a1, a2, a3, a4, a5, a6, a7, a8);
default:
throw new Error("Currying to more than 8-arity is not supported: " + arity);
}
}
export function partialApply(arity, f, args) {
if (f == null) {
return undefined;
}
else if (CURRIED_KEY in f) {
f = f[CURRIED_KEY];
for (let i = 0; i < args.length; i++) {
f = f(args[i]);
}
return f;
}
else {
switch (arity) {
case 1:
// Wrap arguments to make sure .concat doesn't destruct arrays. Example
// [1,2].concat([3,4],5) --> [1,2,3,4,5] // fails
// [1,2].concat([[3,4],5]) --> [1,2,[3,4],5] // ok
return (a1) => f.apply(undefined, args.concat([a1]));
case 2:
return (a1) => (a2) => f.apply(undefined, args.concat([a1, a2]));
case 3:
return (a1) => (a2) => (a3) => f.apply(undefined, args.concat([a1, a2, a3]));
case 4:
return (a1) => (a2) => (a3) => (a4) => f.apply(undefined, args.concat([a1, a2, a3, a4]));
case 5:
return (a1) => (a2) => (a3) => (a4) => (a5) => f.apply(undefined, args.concat([a1, a2, a3, a4, a5]));
case 6:
return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => f.apply(undefined, args.concat([a1, a2, a3, a4, a5, a6]));
case 7:
return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => f.apply(undefined, args.concat([a1, a2, a3, a4, a5, a6, a7]));
case 8:
return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => (a8) => f.apply(undefined, args.concat([a1, a2, a3, a4, a5, a6, a7, a8]));
default:
throw new Error("Partially applying to more than 8-arity is not supported: " + arity);
}
}
}
export function mapCurriedArgs(fn, mappings) {
function mapArg(fn, arg, mappings, idx) {
const mapping = mappings[idx];
if (mapping !== 0) {
const expectedArity = mapping[0];
const actualArity = mapping[1];
if (expectedArity > 1) {
arg = curry(expectedArity, arg);
}
if (actualArity > 1) {
arg = uncurry(actualArity, arg);
}
}
const res = fn(arg);
if (idx + 1 === mappings.length) {
return res;
}
else {
return (arg) => mapArg(res, arg, mappings, idx + 1);
}
}
return (arg) => mapArg(fn, arg, mappings, 0);
}
export function addToDict(dict, k, v) {
if (dict.has(k)) {
throw new Error("An item with the same key has already been added. Key: " + k);
}
dict.set(k, v);
}
export function getItemFromDict(map, key) {
if (map.has(key)) {
return map.get(key);
}
else {
throw new Error(`The given key '${key}' was not present in the dictionary.`);
}
}
//# sourceMappingURL=Util.js.map