compostjs 0.0.8 → 0.0.12

package/dist/fable-library.2.10.1/Observable.js

@@ -1,131 +0,0 @@
-import { tryValueIfChoice1Of2, tryValueIfChoice2Of2, value } from "./Option";
-export class Observer {
-  constructor(onNext, onError, onCompleted) {
-    this.OnNext = onNext;
-
-    this.OnError = onError || (_e => {
-      return;
-    });
-
-    this.OnCompleted = onCompleted || (() => {
-      return;
-    });
-  }
-
-}
-
-class Observable {
-  constructor(subscribe) {
-    this.Subscribe = subscribe;
-  }
-
-}
-
-export function protect(f, succeed, fail) {
-  try {
-    return succeed(f());
-  } catch (e) {
-    fail(e);
-  }
-}
-export function add(callback, source) {
-  source.Subscribe(new Observer(callback));
-}
-export function choose(chooser, source) {
-  return new Observable(observer => source.Subscribe(new Observer(t => protect(() => chooser(t), u => {
-    if (u != null) {
-      observer.OnNext(value(u));
-    }
-  }, observer.OnError), observer.OnError, observer.OnCompleted)));
-}
-export function filter(predicate, source) {
-  return choose(x => predicate(x) ? x : null, source);
-}
-export function map(mapping, source) {
-  return new Observable(observer => source.Subscribe(new Observer(t => {
-    protect(() => mapping(t), observer.OnNext, observer.OnError);
-  }, observer.OnError, observer.OnCompleted)));
-}
-export function merge(source1, source2) {
-  return new Observable(observer => {
-    let stopped = false;
-    let completed1 = false;
-    let completed2 = false;
-    const h1 = source1.Subscribe(new Observer(v => {
-      if (!stopped) {
-        observer.OnNext(v);
-      }
-    }, e => {
-      if (!stopped) {
-        stopped = true;
-        observer.OnError(e);
-      }
-    }, () => {
-      if (!stopped) {
-        completed1 = true;
-
-        if (completed2) {
-          stopped = true;
-          observer.OnCompleted();
-        }
-      }
-    }));
-    const h2 = source2.Subscribe(new Observer(v => {
-      if (!stopped) {
-        observer.OnNext(v);
-      }
-    }, e => {
-      if (!stopped) {
-        stopped = true;
-        observer.OnError(e);
-      }
-    }, () => {
-      if (!stopped) {
-        completed2 = true;
-
-        if (completed1) {
-          stopped = true;
-          observer.OnCompleted();
-        }
-      }
-    }));
-    return {
-      Dispose() {
-        h1.Dispose();
-        h2.Dispose();
-      }
-
-    };
-  });
-}
-export function pairwise(source) {
-  return new Observable(observer => {
-    let last;
-    return source.Subscribe(new Observer(next => {
-      if (last != null) {
-        observer.OnNext([last, next]);
-      }
-
-      last = next;
-    }, observer.OnError, observer.OnCompleted));
-  });
-}
-export function partition(predicate, source) {
-  return [filter(predicate, source), filter(x => !predicate(x), source)];
-}
-export function scan(collector, state, source) {
-  return new Observable(observer => {
-    return source.Subscribe(new Observer(t => {
-      protect(() => collector(state, t), u => {
-        state = u;
-        observer.OnNext(u);
-      }, observer.OnError);
-    }, observer.OnError, observer.OnCompleted));
-  });
-}
-export function split(splitter, source) {
-  return [choose(v => tryValueIfChoice1Of2(splitter(v)), source), choose(v => tryValueIfChoice2Of2(splitter(v)), source)];
-}
-export function subscribe(callback, source) {
-  return source.Subscribe(new Observer(callback));
-}

package/dist/fable-library.2.10.1/Option.js

@@ -1,118 +0,0 @@
-import { Union } from "./Types";
-import { compare, equals, structuralHash } from "./Util"; // Using a class here for better compatibility with TS files importing Some
-
-export class Some {
-  constructor(value) {
-    this.value = value;
-  } // Don't add "Some" for consistency with erased options
-
-
-  toString() {
-    return String(this.value);
-  }
-
-  toJSON() {
-    return this.value;
-  }
-
-  GetHashCode() {
-    return structuralHash(this.value);
-  }
-
-  Equals(other) {
-    if (other == null) {
-      return false;
-    } else {
-      return equals(this.value, other instanceof Some ? other.value : other);
-    }
-  }
-
-  CompareTo(other) {
-    if (other == null) {
-      return 1;
-    } else {
-      return compare(this.value, other instanceof Some ? other.value : other);
-    }
-  }
-
-}
-export function some(x) {
-  return x == null || x instanceof Some ? new Some(x) : x;
-}
-export function value(x) {
-  if (x == null) {
-    throw new Error("Option has no value");
-  } else {
-    return x instanceof Some ? x.value : x;
-  }
-}
-export function tryValue(x) {
-  return x instanceof Some ? x.value : x;
-}
-export function toArray(opt) {
-  return opt == null ? [] : [value(opt)];
-}
-export function defaultArg(opt, defaultValue) {
-  return opt != null ? value(opt) : defaultValue;
-}
-export function defaultArgWith(opt, defThunk) {
-  return opt != null ? value(opt) : defThunk();
-}
-export function filter(predicate, opt) {
-  return opt != null ? predicate(value(opt)) ? opt : undefined : opt;
-}
-export function map(mapping, opt) {
-  return opt != null ? some(mapping(value(opt))) : undefined;
-}
-export function map2(mapping, opt1, opt2) {
-  return opt1 != null && opt2 != null ? mapping(value(opt1), value(opt2)) : undefined;
-}
-export function map3(mapping, opt1, opt2, opt3) {
-  return opt1 != null && opt2 != null && opt3 != null ? mapping(value(opt1), value(opt2), value(opt3)) : undefined;
-}
-export function bind(binder, opt) {
-  return opt != null ? binder(value(opt)) : undefined;
-}
-export function tryOp(op, arg) {
-  try {
-    return some(op(arg));
-  } catch (_a) {
-    return undefined;
-  }
-} // CHOICE
-
-export class Choice extends Union {}
-export class Choice3 extends Union {}
-export class Choice4 extends Union {}
-export class Choice5 extends Union {}
-export class Choice6 extends Union {}
-export class Choice7 extends Union {}
-export function choice1Of2(x) {
-  return new Choice(0, "Choice1Of2", x);
-}
-export function choice2Of2(x) {
-  return new Choice(1, "Choice2Of2", x);
-}
-export function tryValueIfChoice1Of2(x) {
-  return x.tag === 0 ? some(x.fields[0]) : undefined;
-}
-export function tryValueIfChoice2Of2(x) {
-  return x.tag === 1 ? some(x.fields[0]) : undefined;
-} // RESULT
-
-export class Result extends Union {}
-export function ok(x) {
-  return new Result(0, "Ok", x);
-}
-export function error(x) {
-  return new Result(1, "Error", x);
-}
-export function mapOk(f, result) {
-  return result.tag === 0 ? ok(f(result.fields[0])) : result;
-}
-export function mapError(f, result) {
-  return result.tag === 1 ? error(f(result.fields[0])) : result;
-}
-export function bindOk(f, result) {
-  return result.tag === 0 ? f(result.fields[0]) : result;
-}

package/dist/fable-library.2.10.1/Reflection.js

@@ -1,345 +0,0 @@
-import { anonRecord as makeAnonRecord, Record, Union } from "./Types";
-import { compareArraysWith, equalArraysWith } from "./Util";
-export class CaseInfo {
-  constructor(declaringType, tag, name, fields) {
-    this.declaringType = declaringType;
-    this.tag = tag;
-    this.name = name;
-    this.fields = fields;
-  }
-
-}
-export class TypeInfo {
-  constructor(fullname, generics, construct, fields, cases, enumCases) {
-    this.fullname = fullname;
-    this.generics = generics;
-    this.construct = construct;
-    this.fields = fields;
-    this.cases = cases;
-    this.enumCases = enumCases;
-  }
-
-  toString() {
-    return fullName(this);
-  }
-
-  Equals(other) {
-    return equals(this, other);
-  }
-
-  CompareTo(other) {
-    return compare(this, other);
-  }
-
-}
-export function getGenerics(t) {
-  return t.generics != null ? t.generics : [];
-}
-export function equals(t1, t2) {
-  if (t1.fullname === "") {
-    // Anonymous records
-    return t2.fullname === "" && equalArraysWith(getRecordElements(t1), getRecordElements(t2), ([k1, v1], [k2, v2]) => k1 === k2 && equals(v1, v2));
-  } else {
-    return t1.fullname === t2.fullname && equalArraysWith(getGenerics(t1), getGenerics(t2), equals);
-  }
-} // System.Type is not comparable in .NET, but let's implement this
-// in case users want to create a dictionary with types as keys
-
-export function compare(t1, t2) {
-  if (t1.fullname !== t2.fullname) {
-    return t1.fullname < t2.fullname ? -1 : 1;
-  } else {
-    return compareArraysWith(getGenerics(t1), getGenerics(t2), compare);
-  }
-}
-export function class_type(fullname, generics, construct) {
-  return new TypeInfo(fullname, generics, construct);
-}
-export function record_type(fullname, generics, construct, fields) {
-  return new TypeInfo(fullname, generics, construct, fields);
-}
-export function anonRecord_type(...fields) {
-  return new TypeInfo("", undefined, undefined, () => fields);
-}
-export function union_type(fullname, generics, construct, cases) {
-  const t = new TypeInfo(fullname, generics, construct, undefined, () => cases().map((x, i) => typeof x === "string" ? new CaseInfo(t, i, x) : new CaseInfo(t, i, x[0], x[1])));
-  return t;
-}
-export function tuple_type(...generics) {
-  return new TypeInfo("System.Tuple`" + generics.length, generics);
-}
-export function delegate_type(...generics) {
-  return new TypeInfo("System.Func`" + generics.length, generics);
-}
-export function lambda_type(argType, returnType) {
-  return new TypeInfo("Microsoft.FSharp.Core.FSharpFunc`2", [argType, returnType]);
-}
-export function option_type(generic) {
-  return new TypeInfo("Microsoft.FSharp.Core.FSharpOption`1", [generic]);
-}
-export function list_type(generic) {
-  return new TypeInfo("Microsoft.FSharp.Collections.FSharpList`1", [generic]);
-}
-export function array_type(generic) {
-  return new TypeInfo(generic.fullname + "[]", [generic]);
-}
-export function enum_type(fullname, underlyingType, enumCases) {
-  return new TypeInfo(fullname, [underlyingType], undefined, undefined, undefined, enumCases);
-}
-export const obj_type = new TypeInfo("System.Object");
-export const unit_type = new TypeInfo("Microsoft.FSharp.Core.Unit");
-export const char_type = new TypeInfo("System.Char");
-export const string_type = new TypeInfo("System.String");
-export const bool_type = new TypeInfo("System.Boolean");
-export const int8_type = new TypeInfo("System.SByte");
-export const uint8_type = new TypeInfo("System.Byte");
-export const int16_type = new TypeInfo("System.Int16");
-export const uint16_type = new TypeInfo("System.UInt16");
-export const int32_type = new TypeInfo("System.Int32");
-export const uint32_type = new TypeInfo("System.UInt32");
-export const float32_type = new TypeInfo("System.Single");
-export const float64_type = new TypeInfo("System.Double");
-export const decimal_type = new TypeInfo("System.Decimal");
-export function name(info) {
-  if (Array.isArray(info)) {
-    return info[0];
-  } else if (info instanceof CaseInfo) {
-    return info.name;
-  } else {
-    const i = info.fullname.lastIndexOf(".");
-    return i === -1 ? info.fullname : info.fullname.substr(i + 1);
-  }
-}
-export function fullName(t) {
-  const gen = t.generics != null && !isArray(t) ? t.generics : [];
-
-  if (gen.length > 0) {
-    return t.fullname + "[" + gen.map(x => fullName(x)).join(",") + "]";
-  } else {
-    return t.fullname;
-  }
-}
-export function namespace(t) {
-  const i = t.fullname.lastIndexOf(".");
-  return i === -1 ? "" : t.fullname.substr(0, i);
-}
-export function isArray(t) {
-  return t.fullname.endsWith("[]");
-}
-export function getElementType(t) {
-  var _a;
-
-  return isArray(t) ? (_a = t.generics) === null || _a === void 0 ? void 0 : _a[0] : undefined;
-}
-export function isGenericType(t) {
-  return t.generics != null && t.generics.length > 0;
-}
-export function isEnum(t) {
-  return t.enumCases != null && t.enumCases.length > 0;
-}
-/**
- * This doesn't replace types for fields (records) or cases (unions)
- * but it should be enough for type comparison purposes
- */
-
-export function getGenericTypeDefinition(t) {
-  return t.generics == null ? t : new TypeInfo(t.fullname, t.generics.map(() => obj_type));
-}
-export function getEnumUnderlyingType(t) {
-  var _a;
-
-  return (_a = t.generics) === null || _a === void 0 ? void 0 : _a[0];
-}
-export function getEnumValues(t) {
-  if (isEnum(t) && t.enumCases != null) {
-    return t.enumCases.map(kv => kv[1]);
-  } else {
-    throw new Error(`${t.fullname} is not an enum type`);
-  }
-}
-export function getEnumNames(t) {
-  if (isEnum(t) && t.enumCases != null) {
-    return t.enumCases.map(kv => kv[0]);
-  } else {
-    throw new Error(`${t.fullname} is not an enum type`);
-  }
-}
-
-function getEnumCase(t, v) {
-  if (t.enumCases != null) {
-    if (typeof v === "string") {
-      for (const kv of t.enumCases) {
-        if (kv[0] === v) {
-          return kv;
-        }
-      }
-
-      throw new Error(`'${v}' was not found in ${t.fullname}`);
-    } else {
-      for (const kv of t.enumCases) {
-        if (kv[1] === v) {
-          return kv;
-        }
-      } // .NET returns the number even if it doesn't match any of the cases
-
-
-      return ["", v];
-    }
-  } else {
-    throw new Error(`${t.fullname} is not an enum type`);
-  }
-}
-
-export function parseEnum(t, str) {
-  // TODO: better int parsing here, parseInt ceils floats: "4.8" -> 4
-  const value = parseInt(str, 10);
-  return getEnumCase(t, isNaN(value) ? str : value)[1];
-}
-export function tryParseEnum(t, str) {
-  try {
-    const v = parseEnum(t, str);
-    return [true, v];
-  } catch (_a) {// supress error
-  }
-
-  return [false, NaN];
-}
-export function getEnumName(t, v) {
-  return getEnumCase(t, v)[0];
-}
-export function isEnumDefined(t, v) {
-  try {
-    const kv = getEnumCase(t, v);
-    return kv[0] != null && kv[0] !== "";
-  } catch (_a) {// supress error
-  }
-
-  return false;
-} // FSharpType
-
-export function getUnionCases(t) {
-  if (t.cases != null) {
-    return t.cases();
-  } else {
-    throw new Error(`${t.fullname} is not an F# union type`);
-  }
-}
-export function getRecordElements(t) {
-  if (t.fields != null) {
-    return t.fields();
-  } else {
-    throw new Error(`${t.fullname} is not an F# record type`);
-  }
-}
-export function getTupleElements(t) {
-  if (isTuple(t) && t.generics != null) {
-    return t.generics;
-  } else {
-    throw new Error(`${t.fullname} is not a tuple type`);
-  }
-}
-export function getFunctionElements(t) {
-  if (isFunction(t) && t.generics != null) {
-    const gen = t.generics;
-    return [gen[0], gen[1]];
-  } else {
-    throw new Error(`${t.fullname} is not an F# function type`);
-  }
-}
-export function isUnion(t) {
-  return t instanceof TypeInfo ? t.cases != null : t instanceof Union;
-}
-export function isRecord(t) {
-  return t instanceof TypeInfo ? t.fields != null : t instanceof Record;
-}
-export function isTuple(t) {
-  return t.fullname.startsWith("System.Tuple");
-} // In .NET this is false for delegates
-
-export function isFunction(t) {
-  return t.fullname === "Microsoft.FSharp.Core.FSharpFunc`2";
-} // FSharpValue
-
-export function getUnionFields(v, t) {
-  const cases = getUnionCases(t);
-  const case_ = cases[v.tag];
-
-  if (case_ == null) {
-    throw new Error(`Cannot find case ${v.name} in union type`);
-  }
-
-  return [case_, v.fields];
-}
-export function getUnionCaseFields(uci) {
-  return uci.fields == null ? [] : uci.fields;
-}
-export function getRecordFields(v) {
-  return Object.keys(v).map(k => v[k]);
-}
-export function getRecordField(v, field) {
-  return v[field[0]];
-}
-export function getTupleFields(v) {
-  return v;
-}
-export function getTupleField(v, i) {
-  return v[i];
-}
-export function makeUnion(uci, values) {
-  const expectedLength = (uci.fields || []).length;
-
-  if (values.length !== expectedLength) {
-    throw new Error(`Expected an array of length ${expectedLength} but got ${values.length}`);
-  }
-
-  return uci.declaringType.construct != null ? new uci.declaringType.construct(uci.tag, uci.name, ...values) : {};
-}
-export function makeRecord(t, values) {
-  const fields = getRecordElements(t);
-
-  if (fields.length !== values.length) {
-    throw new Error(`Expected an array of length ${fields.length} but got ${values.length}`);
-  }
-
-  return t.construct != null ? new t.construct(...values) : makeAnonRecord(fields.reduce((obj, [key, _t], i) => {
-    obj[key] = values[i];
-    return obj;
-  }, {}));
-}
-export function makeTuple(values, _t) {
-  return values;
-}
-export function makeGenericType(t, generics) {
-  return new TypeInfo(t.fullname, generics, t.construct, t.fields, t.cases);
-}
-export function createInstance(t, consArgs) {
-  // TODO: Check if consArgs length is same as t.construct?
-  // (Arg types can still be different)
-  if (typeof t.construct === "function") {
-    return new t.construct(...(consArgs !== null && consArgs !== void 0 ? consArgs : []));
-  } else {
-    throw new Error(`Cannot access constructor of ${t.fullname}`);
-  }
-}
-export function getValue(propertyInfo, v) {
-  return v[propertyInfo[0]];
-} // Fable.Core.Reflection
-
-function assertUnion(x) {
-  if (!(x instanceof Union)) {
-    throw new Error(`Value is not an F# union type`);
-  }
-}
-
-export function getCaseTag(x) {
-  assertUnion(x);
-  return x.tag;
-}
-export function getCaseName(x) {
-  assertUnion(x);
-  return x.name;
-}
-export function getCaseFields(x) {
-  assertUnion(x);
-  return x.fields;
-}

package/dist/fable-library.2.10.1/RegExp.js

@@ -1,118 +0,0 @@
-export function create(pattern, options = 0) {
-  // Supported RegexOptions
-  // * IgnoreCase:  0x0001
-  // * Multiline:   0x0002
-  // * Singleline:  0x0010
-  // * ECMAScript:  0x0100 (ignored)
-  if ((options & ~(1 ^ 2 ^ 16 ^ 256)) !== 0) {
-    throw new Error("RegexOptions only supports: IgnoreCase, Multiline, Singleline and ECMAScript");
-  }
-
-  let flags = "g";
-  flags += options & 1 ? "i" : ""; // 0x0001 RegexOptions.IgnoreCase
-
-  flags += options & 2 ? "m" : "";
-  flags += options & 16 ? "s" : "";
-  return new RegExp(pattern, flags);
-} // From http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex
-
-export function escape(str) {
-  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
-}
-export function unescape(str) {
-  return str.replace(/\\([\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|])/g, "$1");
-}
-export function isMatch(str, pattern, options = 0) {
-  let reg;
-  reg = str instanceof RegExp ? (reg = str, str = pattern, reg.lastIndex = options, reg) : reg = create(pattern, options);
-  return reg.test(str);
-}
-export function match(str, pattern, options = 0) {
-  let reg;
-  reg = str instanceof RegExp ? (reg = str, str = pattern, reg.lastIndex = options, reg) : reg = create(pattern, options);
-  return reg.exec(str);
-}
-export function matches(str, pattern, options = 0) {
-  let reg;
-  reg = str instanceof RegExp ? (reg = str, str = pattern, reg.lastIndex = options, reg) : reg = create(pattern, options);
-
-  if (!reg.global) {
-    throw new Error("Non-global RegExp"); // Prevent infinite loop
-  }
-
-  let m = reg.exec(str);
-  const matches = [];
-
-  while (m !== null) {
-    matches.push(m);
-    m = reg.exec(str);
-  }
-
-  return matches;
-}
-export function options(reg) {
-  let options = 256; // ECMAScript
-
-  options |= reg.ignoreCase ? 1 : 0;
-  options |= reg.multiline ? 2 : 0;
-  return options;
-}
-export function replace(reg, input, replacement, limit, offset = 0) {
-  function replacer() {
-    let res = arguments[0];
-
-    if (limit) {
-      limit--;
-      const match = [];
-      const len = arguments.length;
-
-      for (let i = 0; i < len - 2; i++) {
-        match.push(arguments[i]);
-      }
-
-      match.index = arguments[len - 2];
-      match.input = arguments[len - 1];
-      res = replacement(match);
-    }
-
-    return res;
-  }
-
-  if (typeof reg === "string") {
-    const tmp = reg;
-    reg = create(input, limit !== null && limit !== void 0 ? limit : 0);
-    input = tmp;
-    limit = undefined;
-  }
-
-  if (typeof replacement === "function") {
-    limit = limit == null ? -1 : limit;
-    return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);
-  } else {
-    // $0 doesn't work with JS regex, see #1155
-    replacement = replacement.replace(/\$0/g, _s => "$&");
-
-    if (limit != null) {
-      let m;
-      const sub1 = input.substring(offset);
-
-      const _matches = matches(reg, sub1);
-
-      const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;
-      return input.substring(0, offset) + sub2.replace(reg, replacement) + input.substring(offset + sub2.length);
-    } else {
-      return input.replace(reg, replacement);
-    }
-  }
-}
-export function split(reg, input, limit, offset = 0) {
-  if (typeof reg === "string") {
-    const tmp = reg;
-    reg = create(input, limit !== null && limit !== void 0 ? limit : 0);
-    input = tmp;
-    limit = undefined;
-  }
-
-  input = input.substring(offset);
-  return input.split(reg, limit);
-}