tutuca 0.9.8 → 0.9.10

package/dist/tutuca-dev.js

@@ -5114,7 +5114,11 @@ function shallowCopy(from) {
     ...from
   };
 }
+var merge$1 = (collection, ...sources) => mergeWithSources(collection, sources);
+var mergeWith$1 = (merger, collection, ...sources) => mergeWithSources(collection, sources, merger);
 var mergeDeepWithSources = (collection, sources, merger) => mergeWithSources(collection, sources, deepMergerWith(merger));
+var mergeDeep$1 = (collection, ...sources) => mergeDeepWithSources(collection, sources);
+var mergeDeepWith$1 = (merger, collection, ...sources) => mergeDeepWithSources(collection, sources, merger);
 function mergeWithSources(collection, sources, merger) {
   if (!isDataStructure(collection)) {
     throw new TypeError(`Cannot merge into non-data-structure value: ${collection}`);
@@ -6402,6 +6406,10 @@ class OrderedSetImpl extends SetImpl {
 OrderedSet.isOrderedSet = isOrderedSet;
 var makeOrderedSet = (map, ownerID) => new OrderedSetImpl(map, ownerID);
 var emptyOrderedSet = () => makeOrderedSet(emptyOrderedMap());
+var PairSorting = {
+  LeftThenRight: -1,
+  RightThenLeft: 1
+};
 function throwOnInvalidDefaultValues(defaultValues) {
   if (isRecord(defaultValues)) {
     throw new Error("Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.");
@@ -6427,6 +6435,7 @@ var Record = (defaultValues, name) => {
       hasInitialized = true;
       const keys = Object.keys(defaultValues);
       const indices = RecordTypePrototype._indices = {};
+      RecordTypePrototype._name = name;
       RecordTypePrototype._keys = keys;
       RecordTypePrototype._defaultValues = defaultValues;
       for (let i = 0;i < keys.length; i++) {
@@ -6734,6 +6743,11 @@ class RangeImpl extends IndexedSeqImpl {
     this.prototype[Symbol.iterator] = this.prototype.values;
   }
 }
+var Repeat = (value, times) => {
+  const size = times === undefined ? Infinity : Math.max(0, times);
+  return new RepeatImpl(value, size);
+};
+
 class RepeatImpl extends IndexedSeqImpl {
   constructor(value, size) {
     super();
@@ -6820,6 +6834,89 @@ class RepeatImpl extends IndexedSeqImpl {
     this.prototype[Symbol.iterator] = this.prototype.values;
   }
 }
+var fromJS = (value, converter) => fromJSWith([], converter ?? defaultConverter, value, "", converter?.length > 2 ? [] : undefined, {
+  "": value
+});
+function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
+  if (typeof value !== "string" && !isImmutable(value) && (isArrayLike(value) || hasIterator(value) || isPlainObject(value))) {
+    if (stack.includes(value)) {
+      throw new TypeError("Cannot convert circular structure to Immutable");
+    }
+    stack.push(value);
+    if (keyPath && key !== "") {
+      keyPath.push(key);
+    }
+    const converted = converter.call(parentValue, key, Seq(value).map((v, k) => fromJSWith(stack, converter, v, k, keyPath, value)), keyPath && keyPath.slice());
+    stack.pop();
+    if (keyPath) {
+      keyPath.pop();
+    }
+    return converted;
+  }
+  return value;
+}
+var defaultConverter = (k, v) => isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
+var asValues = (collection) => isKeyed(collection) ? collection.valueSeq() : collection;
+function initCollectionConversions() {
+  CollectionImpl.prototype.toMap = function toMap() {
+    return Map2(this.toKeyedSeq());
+  };
+  CollectionImpl.prototype.toOrderedMap = function toOrderedMap() {
+    return OrderedMap(this.toKeyedSeq());
+  };
+  CollectionImpl.prototype.toOrderedSet = function toOrderedSet() {
+    return OrderedSet(asValues(this));
+  };
+  CollectionImpl.prototype.toSet = function toSet() {
+    return Set2(asValues(this));
+  };
+  CollectionImpl.prototype.toStack = function toStack() {
+    return Stack2(asValues(this));
+  };
+  CollectionImpl.prototype.toList = function toList() {
+    return List(asValues(this));
+  };
+  CollectionImpl.prototype.countBy = function countBy(grouper, context) {
+    const groups = Map2().asMutable();
+    this.__iterate((v, k) => {
+      groups.update(grouper.call(context, v, k, this), 0, (a) => a + 1);
+    });
+    return groups.asImmutable();
+  };
+  CollectionImpl.prototype.groupBy = function groupBy(grouper, context) {
+    const isKeyedIter = isKeyed(this);
+    const groups = (isOrdered(this) ? OrderedMap() : Map2()).asMutable();
+    this.__iterate((v, k) => {
+      groups.update(grouper.call(context, v, k, this), (a) => {
+        a ??= [];
+        a.push(isKeyedIter ? [k, v] : v);
+        return a;
+      });
+    });
+    return groups.map((arr) => reifyValues(this, arr)).asImmutable();
+  };
+  IndexedCollectionImpl.prototype.keySeq = function keySeq() {
+    return Range(0, this.size);
+  };
+  MapImpl.prototype.sort = function sort(comparator) {
+    return OrderedMap(sortFactory(this, comparator));
+  };
+  MapImpl.prototype.sortBy = function sortBy(mapper, comparator) {
+    return OrderedMap(sortFactory(this, comparator, mapper));
+  };
+  SetImpl.prototype.sort = function sort(comparator) {
+    return OrderedSet(sortFactory(this, comparator));
+  };
+  SetImpl.prototype.sortBy = function sortBy(mapper, comparator) {
+    return OrderedSet(sortFactory(this, comparator, mapper));
+  };
+}
+var version$1 = "7.0.0";
+var pkg = {
+  version: version$1
+};
+initCollectionConversions();
+var { version } = pkg;
 
 // src/oo.js
 var BAD_VALUE = Symbol("BadValue");
@@ -8097,18 +8194,47 @@ class LintParseContext extends ParseContext {
   }
 }
 export {
+  version,
+  updateIn$1 as updateIn,
+  update$1 as update,
   tutuca,
+  setIn$1 as setIn,
+  set,
   seqInfoByClass,
+  removeIn,
+  remove,
+  mergeWith$1 as mergeWith,
+  mergeDeepWith$1 as mergeDeepWith,
+  mergeDeep$1 as mergeDeep,
+  merge$1 as merge,
   macro,
+  isValueObject,
+  isStack,
+  isSet,
+  isSeq,
+  isRecord,
+  isPlainObject,
+  isOrderedSet,
   isOrderedMap,
+  isOrdered,
   isOrderedMap as isOMap,
   isMap,
   isList,
   isKeyed,
   isIndexed,
+  isImmutable,
   isMap as isIMap,
+  isCollection,
+  isAssociative,
+  is,
   injectCss,
   html,
+  hash,
+  hasIn$1 as hasIn,
+  has,
+  getIn$1 as getIn,
+  get,
+  fromJS,
   fieldsByClass,
   css,
   component,
@@ -8120,10 +8246,19 @@ export {
   UNKNOWN_HANDLER_ARG_NAME,
   UNKNOWN_EVENT_MODIFIER,
   UNKNOWN_COMPONENT_NAME,
+  Stack2 as Stack,
+  Set2 as Set,
+  Seq,
+  Repeat,
   Record,
+  Range,
   RENDER_IT_OUTSIDE_OF_LOOP,
   ParseContext,
+  PairSorting,
+  OrderedSet,
+  OrderedMap,
   OrderedMap as OMap,
+  Map2 as Map,
   List,
   LintParseContext,
   LintContext,
@@ -8138,5 +8273,6 @@ export {
   INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD,
   Map2 as IMap,
   FIELD_VAL_NOT_DEFINED,
+  Collection,
   COMPUTED_VAL_NOT_DEFINED
 };