@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/util/Map.Entry/index.d.ts

@@ -0,0 +1,137 @@
+import type { Object } from "../../lang/Object";
+
+import type { Comparator } from "../Comparator";
+
+/**
+ * A map entry (key-value pair).  The <tt>Map.entrySet</tt> method returns
+ *  a collection-view of the map, whose elements are of this class.  The
+ *  <i>only</i> way to obtain a reference to a map entry is from the
+ *  iterator of this collection-view.  These <tt>Map.Entry</tt> objects are
+ *  valid <i>only</i> for the duration of the iteration; more formally,
+ *  the behavior of a map entry is undefined if the backing map has been
+ *  modified after the entry was returned by the iterator, except through
+ *  the <tt>setValue</tt> operation on the map entry.
+ * @see Map#entrySet()
+ * @since 1.2
+ */
+export type Entry = {
+  /**
+   * Returns the key corresponding to this entry.
+   * @return the key corresponding to this entry
+   * @throws IllegalStateException implementations may, but are not&#xA; required to, throw this exception if the entry has been&#xA; removed from the backing map.
+   */
+  getKey(): unknown;
+
+  /**
+   * Returns the value corresponding to this entry.  If the mapping
+   *  has been removed from the backing map (by the iterator's
+   *  <tt>remove</tt> operation), the results of this call are undefined.
+   * @return the value corresponding to this entry
+   * @throws IllegalStateException implementations may, but are not&#xA; required to, throw this exception if the entry has been&#xA; removed from the backing map.
+   */
+  getValue(): unknown;
+
+  /**
+   * Replaces the value corresponding to this entry with the specified
+   *  value (optional operation).  (Writes through to the map.)  The
+   *  behavior of this call is undefined if the mapping has already been
+   *  removed from the map (by the iterator's <tt>remove</tt> operation).
+   * @param value new value to be stored in this entry
+   * @return old value corresponding to the entry
+   * @throws UnsupportedOperationException if the <tt>put</tt> operation&#xA; is not supported by the backing map
+   * @throws ClassCastException if the class of the specified value&#xA; prevents it from being stored in the backing map
+   * @throws NullPointerException if the backing map does not permit&#xA; null values, and the specified value is null
+   * @throws IllegalArgumentException if some property of this value&#xA; prevents it from being stored in the backing map
+   * @throws IllegalStateException implementations may, but are not&#xA; required to, throw this exception if the entry has been&#xA; removed from the backing map.
+   */
+  setValue(value: unknown): unknown;
+
+  /**
+   * Compares the specified object with this entry for equality.
+   *  Returns <tt>true</tt> if the given object is also a map entry and
+   *  the two entries represent the same mapping.  More formally, two
+   *  entries <tt>e1</tt> and <tt>e2</tt> represent the same mapping
+   *  if<pre>
+   *      (e1.getKey()==null ?
+   *       e2.getKey()==null : e1.getKey().equals(e2.getKey()))  &amp;&amp;
+   *      (e1.getValue()==null ?
+   *       e2.getValue()==null : e1.getValue().equals(e2.getValue()))
+   *  </pre>
+   *  This ensures that the <tt>equals</tt> method works properly across
+   *  different implementations of the <tt>Map.Entry</tt> interface.
+   * @param o object to be compared for equality with this map entry
+   * @return <tt>true</tt> if the specified object is equal to this map&#xA; entry
+   */
+  equals(o: unknown): boolean;
+
+  /**
+   * Returns the hash code value for this map entry.  The hash code
+   *  of a map entry <tt>e</tt> is defined to be: <pre>
+   *      (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^
+   *      (e.getValue()==null ? 0 : e.getValue().hashCode())
+   *  </pre>
+   *  This ensures that <tt>e1.equals(e2)</tt> implies that
+   *  <tt>e1.hashCode()==e2.hashCode()</tt> for any two Entries
+   *  <tt>e1</tt> and <tt>e2</tt>, as required by the general
+   *  contract of <tt>Object.hashCode</tt>.
+   * @return the hash code value for this map entry
+   * @see Object#hashCode()
+   * @see Object#equals(Object)
+   * @see #equals(Object)
+   */
+  hashCode(): number;
+
+  /**
+   * Returns a comparator that compares {@link Map.Entry} in natural order on key.
+   *
+   *  <p>The returned comparator is serializable and throws {@link
+   *  NullPointerException} when comparing an entry with a null key.
+   * @param <K> the {@link Comparable} type of then map keys
+   * @param <V> the type of the map values
+   * @return a comparator that compares {@link Map.Entry} in natural order on key.
+   * @see Comparable
+   * @since 1.8
+   */
+  comparingByKey(): Comparator;
+
+  /**
+   * Returns a comparator that compares {@link Map.Entry} in natural order on value.
+   *
+   *  <p>The returned comparator is serializable and throws {@link
+   *  NullPointerException} when comparing an entry with null values.
+   * @param <K> the type of the map keys
+   * @param <V> the {@link Comparable} type of the map values
+   * @return a comparator that compares {@link Map.Entry} in natural order on value.
+   * @see Comparable
+   * @since 1.8
+   */
+  comparingByValue(): Comparator;
+
+  /**
+   * Returns a comparator that compares {@link Map.Entry} by key using the given
+   *  {@link Comparator}.
+   *
+   *  <p>The returned comparator is serializable if the specified comparator
+   *  is also serializable.
+   * @param <K> the type of the map keys
+   * @param <V> the type of the map values
+   * @param cmp the key {@link Comparator}
+   * @return a comparator that compares {@link Map.Entry} by the key.
+   * @since 1.8
+   */
+  comparingByKey(cmp: Comparator): Comparator;
+
+  /**
+   * Returns a comparator that compares {@link Map.Entry} by value using the given
+   *  {@link Comparator}.
+   *
+   *  <p>The returned comparator is serializable if the specified comparator
+   *  is also serializable.
+   * @param <K> the type of the map keys
+   * @param <V> the type of the map values
+   * @param cmp the value {@link Comparator}
+   * @return a comparator that compares {@link Map.Entry} by the value.
+   * @since 1.8
+   */
+  comparingByValue(cmp: Comparator): Comparator;
+};

package/types/java/util/Map.Entry/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getKey: function getKey() {},
+  getValue: function getValue() {},
+  setValue: function setValue() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  comparingByKey: function comparingByKey() {},
+  comparingByValue: function comparingByValue() {}
+};
+exports["default"] = _default;

package/types/java/util/NavigableMap/index.d.ts

@@ -0,0 +1,314 @@
+import type { Entry } from "../Map.Entry";
+import type { NavigableSet } from "../NavigableSet";
+
+import type { SortedMap } from "../SortedMap";
+
+/**
+ * A {@link SortedMap} extended with navigation methods returning the
+ *  closest matches for given search targets. Methods
+ *  {@code lowerEntry}, {@code floorEntry}, {@code ceilingEntry},
+ *  and {@code higherEntry} return {@code Map.Entry} objects
+ *  associated with keys respectively less than, less than or equal,
+ *  greater than or equal, and greater than a given key, returning
+ *  {@code null} if there is no such key.  Similarly, methods
+ *  {@code lowerKey}, {@code floorKey}, {@code ceilingKey}, and
+ *  {@code higherKey} return only the associated keys. All of these
+ *  methods are designed for locating, not traversing entries.
+ *
+ *  <p>A {@code NavigableMap} may be accessed and traversed in either
+ *  ascending or descending key order.  The {@code descendingMap}
+ *  method returns a view of the map with the senses of all relational
+ *  and directional methods inverted. The performance of ascending
+ *  operations and views is likely to be faster than that of descending
+ *  ones.  Methods {@code subMap}, {@code headMap},
+ *  and {@code tailMap} differ from the like-named {@code
+ *  SortedMap} methods in accepting additional arguments describing
+ *  whether lower and upper bounds are inclusive versus exclusive.
+ *  Submaps of any {@code NavigableMap} must implement the {@code
+ *  NavigableMap} interface.
+ *
+ *  <p>This interface additionally defines methods {@code firstEntry},
+ *  {@code pollFirstEntry}, {@code lastEntry}, and
+ *  {@code pollLastEntry} that return and/or remove the least and
+ *  greatest mappings, if any exist, else returning {@code null}.
+ *
+ *  <p>Implementations of entry-returning methods are expected to
+ *  return {@code Map.Entry} pairs representing snapshots of mappings
+ *  at the time they were produced, and thus generally do <em>not</em>
+ *  support the optional {@code Entry.setValue} method. Note however
+ *  that it is possible to change mappings in the associated map using
+ *  method {@code put}.
+ *
+ *  <p>Methods
+ *  {@link #subMap(Object, Object) subMap(K, K)},
+ *  {@link #headMap(Object) headMap(K)}, and
+ *  {@link #tailMap(Object) tailMap(K)}
+ *  are specified to return {@code SortedMap} to allow existing
+ *  implementations of {@code SortedMap} to be compatibly retrofitted to
+ *  implement {@code NavigableMap}, but extensions and implementations
+ *  of this interface are encouraged to override these methods to return
+ *  {@code NavigableMap}.  Similarly,
+ *  {@link #keySet()} can be overriden to return {@code NavigableSet}.
+ *
+ *  <p>This interface is a member of the
+ *  <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ *  Java Collections Framework</a>.
+ * @author Doug Lea
+ * @author Josh Bloch
+ * @param <K> the type of keys maintained by this map
+ * @param <V> the type of mapped values
+ * @since 1.6
+ */
+export type NavigableMap = SortedMap & {
+  /**
+   * Returns a key-value mapping associated with the greatest key
+   *  strictly less than the given key, or {@code null} if there is
+   *  no such key.
+   * @param key the key
+   * @return an entry with the greatest key less than {@code key},&#xA; or {@code null} if there is no such key
+   * @throws ClassCastException if the specified key cannot be compared&#xA; with the keys currently in the map
+   * @throws NullPointerException if the specified key is null&#xA; and this map does not permit null keys
+   */
+  lowerEntry(key: unknown): Entry;
+
+  /**
+   * Returns the greatest key strictly less than the given key, or
+   *  {@code null} if there is no such key.
+   * @param key the key
+   * @return the greatest key less than {@code key},&#xA; or {@code null} if there is no such key
+   * @throws ClassCastException if the specified key cannot be compared&#xA; with the keys currently in the map
+   * @throws NullPointerException if the specified key is null&#xA; and this map does not permit null keys
+   */
+  lowerKey(key: unknown): unknown;
+
+  /**
+   * Returns a key-value mapping associated with the greatest key
+   *  less than or equal to the given key, or {@code null} if there
+   *  is no such key.
+   * @param key the key
+   * @return an entry with the greatest key less than or equal to&#xA; {@code key}, or {@code null} if there is no such key
+   * @throws ClassCastException if the specified key cannot be compared&#xA; with the keys currently in the map
+   * @throws NullPointerException if the specified key is null&#xA; and this map does not permit null keys
+   */
+  floorEntry(key: unknown): Entry;
+
+  /**
+   * Returns the greatest key less than or equal to the given key,
+   *  or {@code null} if there is no such key.
+   * @param key the key
+   * @return the greatest key less than or equal to {@code key},&#xA; or {@code null} if there is no such key
+   * @throws ClassCastException if the specified key cannot be compared&#xA; with the keys currently in the map
+   * @throws NullPointerException if the specified key is null&#xA; and this map does not permit null keys
+   */
+  floorKey(key: unknown): unknown;
+
+  /**
+   * Returns a key-value mapping associated with the least key
+   *  greater than or equal to the given key, or {@code null} if
+   *  there is no such key.
+   * @param key the key
+   * @return an entry with the least key greater than or equal to&#xA; {@code key}, or {@code null} if there is no such key
+   * @throws ClassCastException if the specified key cannot be compared&#xA; with the keys currently in the map
+   * @throws NullPointerException if the specified key is null&#xA; and this map does not permit null keys
+   */
+  ceilingEntry(key: unknown): Entry;
+
+  /**
+   * Returns the least key greater than or equal to the given key,
+   *  or {@code null} if there is no such key.
+   * @param key the key
+   * @return the least key greater than or equal to {@code key},&#xA; or {@code null} if there is no such key
+   * @throws ClassCastException if the specified key cannot be compared&#xA; with the keys currently in the map
+   * @throws NullPointerException if the specified key is null&#xA; and this map does not permit null keys
+   */
+  ceilingKey(key: unknown): unknown;
+
+  /**
+   * Returns a key-value mapping associated with the least key
+   *  strictly greater than the given key, or {@code null} if there
+   *  is no such key.
+   * @param key the key
+   * @return an entry with the least key greater than {@code key},&#xA; or {@code null} if there is no such key
+   * @throws ClassCastException if the specified key cannot be compared&#xA; with the keys currently in the map
+   * @throws NullPointerException if the specified key is null&#xA; and this map does not permit null keys
+   */
+  higherEntry(key: unknown): Entry;
+
+  /**
+   * Returns the least key strictly greater than the given key, or
+   *  {@code null} if there is no such key.
+   * @param key the key
+   * @return the least key greater than {@code key},&#xA; or {@code null} if there is no such key
+   * @throws ClassCastException if the specified key cannot be compared&#xA; with the keys currently in the map
+   * @throws NullPointerException if the specified key is null&#xA; and this map does not permit null keys
+   */
+  higherKey(key: unknown): unknown;
+
+  /**
+   * Returns a key-value mapping associated with the least
+   *  key in this map, or {@code null} if the map is empty.
+   * @return an entry with the least key,&#xA; or {@code null} if this map is empty
+   */
+  firstEntry(): Entry;
+
+  /**
+   * Returns a key-value mapping associated with the greatest
+   *  key in this map, or {@code null} if the map is empty.
+   * @return an entry with the greatest key,&#xA; or {@code null} if this map is empty
+   */
+  lastEntry(): Entry;
+
+  /**
+   * Removes and returns a key-value mapping associated with
+   *  the least key in this map, or {@code null} if the map is empty.
+   * @return the removed first entry of this map,&#xA; or {@code null} if this map is empty
+   */
+  pollFirstEntry(): Entry;
+
+  /**
+   * Removes and returns a key-value mapping associated with
+   *  the greatest key in this map, or {@code null} if the map is empty.
+   * @return the removed last entry of this map,&#xA; or {@code null} if this map is empty
+   */
+  pollLastEntry(): Entry;
+
+  /**
+   * Returns a reverse order view of the mappings contained in this map.
+   *  The descending map is backed by this map, so changes to the map are
+   *  reflected in the descending map, and vice-versa.  If either map is
+   *  modified while an iteration over a collection view of either map
+   *  is in progress (except through the iterator's own {@code remove}
+   *  operation), the results of the iteration are undefined.
+   *
+   *  <p>The returned map has an ordering equivalent to
+   *  <tt>{@link Collections#reverseOrder(Comparator) Collections.reverseOrder}(comparator())</tt>.
+   *  The expression {@code m.descendingMap().descendingMap()} returns a
+   *  view of {@code m} essentially equivalent to {@code m}.
+   * @return a reverse order view of this map
+   */
+  descendingMap(): NavigableMap;
+
+  /**
+   * Returns a {@link NavigableSet} view of the keys contained in this map.
+   *  The set's iterator returns the keys in ascending order.
+   *  The set is backed by the map, so changes to the map are reflected in
+   *  the set, and vice-versa.  If the map is modified while an iteration
+   *  over the set is in progress (except through the iterator's own {@code
+   *  remove} operation), the results of the iteration are undefined.  The
+   *  set supports element removal, which removes the corresponding mapping
+   *  from the map, via the {@code Iterator.remove}, {@code Set.remove},
+   *  {@code removeAll}, {@code retainAll}, and {@code clear} operations.
+   *  It does not support the {@code add} or {@code addAll} operations.
+   * @return a navigable set view of the keys in this map
+   */
+  navigableKeySet(): NavigableSet;
+
+  /**
+   * Returns a reverse order {@link NavigableSet} view of the keys contained in this map.
+   *  The set's iterator returns the keys in descending order.
+   *  The set is backed by the map, so changes to the map are reflected in
+   *  the set, and vice-versa.  If the map is modified while an iteration
+   *  over the set is in progress (except through the iterator's own {@code
+   *  remove} operation), the results of the iteration are undefined.  The
+   *  set supports element removal, which removes the corresponding mapping
+   *  from the map, via the {@code Iterator.remove}, {@code Set.remove},
+   *  {@code removeAll}, {@code retainAll}, and {@code clear} operations.
+   *  It does not support the {@code add} or {@code addAll} operations.
+   * @return a reverse order navigable set view of the keys in this map
+   */
+  descendingKeySet(): NavigableSet;
+
+  /**
+   * Returns a view of the portion of this map whose keys range from
+   *  {@code fromKey} to {@code toKey}.  If {@code fromKey} and
+   *  {@code toKey} are equal, the returned map is empty unless
+   *  {@code fromInclusive} and {@code toInclusive} are both true.  The
+   *  returned map is backed by this map, so changes in the returned map are
+   *  reflected in this map, and vice-versa.  The returned map supports all
+   *  optional map operations that this map supports.
+   *
+   *  <p>The returned map will throw an {@code IllegalArgumentException}
+   *  on an attempt to insert a key outside of its range, or to construct a
+   *  submap either of whose endpoints lie outside its range.
+   * @param fromKey low endpoint of the keys in the returned map
+   * @param fromInclusive {@code true} if the low endpoint&#xA; is to be included in the returned view
+   * @param toKey high endpoint of the keys in the returned map
+   * @param toInclusive {@code true} if the high endpoint&#xA; is to be included in the returned view
+   * @return a view of the portion of this map whose keys range from&#xA; {@code fromKey} to {@code toKey}
+   * @throws ClassCastException if {@code fromKey} and {@code toKey}&#xA; cannot be compared to one another using this map's comparator&#xA; (or, if the map has no comparator, using natural ordering).&#xA; Implementations may, but are not required to, throw this&#xA; exception if {@code fromKey} or {@code toKey}&#xA; cannot be compared to keys currently in the map.
+   * @throws NullPointerException if {@code fromKey} or {@code toKey}&#xA; is null and this map does not permit null keys
+   * @throws IllegalArgumentException if {@code fromKey} is greater than&#xA; {@code toKey}; or if this map itself has a restricted&#xA; range, and {@code fromKey} or {@code toKey} lies&#xA; outside the bounds of the range
+   */
+  subMap(
+    fromKey: unknown,
+    fromInclusive: boolean,
+    toKey: unknown,
+    toInclusive: boolean
+  ): NavigableMap;
+
+  /**
+   * Returns a view of the portion of this map whose keys are less than (or
+   *  equal to, if {@code inclusive} is true) {@code toKey}.  The returned
+   *  map is backed by this map, so changes in the returned map are reflected
+   *  in this map, and vice-versa.  The returned map supports all optional
+   *  map operations that this map supports.
+   *
+   *  <p>The returned map will throw an {@code IllegalArgumentException}
+   *  on an attempt to insert a key outside its range.
+   * @param toKey high endpoint of the keys in the returned map
+   * @param inclusive {@code true} if the high endpoint&#xA; is to be included in the returned view
+   * @return a view of the portion of this map whose keys are less than&#xA; (or equal to, if {@code inclusive} is true) {@code toKey}
+   * @throws ClassCastException if {@code toKey} is not compatible&#xA; with this map's comparator (or, if the map has no comparator,&#xA; if {@code toKey} does not implement {@link Comparable}).&#xA; Implementations may, but are not required to, throw this&#xA; exception if {@code toKey} cannot be compared to keys&#xA; currently in the map.
+   * @throws NullPointerException if {@code toKey} is null&#xA; and this map does not permit null keys
+   * @throws IllegalArgumentException if this map itself has a&#xA; restricted range, and {@code toKey} lies outside the&#xA; bounds of the range
+   */
+  headMap(toKey: unknown, inclusive: boolean): NavigableMap;
+
+  /**
+   * Returns a view of the portion of this map whose keys are greater than (or
+   *  equal to, if {@code inclusive} is true) {@code fromKey}.  The returned
+   *  map is backed by this map, so changes in the returned map are reflected
+   *  in this map, and vice-versa.  The returned map supports all optional
+   *  map operations that this map supports.
+   *
+   *  <p>The returned map will throw an {@code IllegalArgumentException}
+   *  on an attempt to insert a key outside its range.
+   * @param fromKey low endpoint of the keys in the returned map
+   * @param inclusive {@code true} if the low endpoint&#xA; is to be included in the returned view
+   * @return a view of the portion of this map whose keys are greater than&#xA; (or equal to, if {@code inclusive} is true) {@code fromKey}
+   * @throws ClassCastException if {@code fromKey} is not compatible&#xA; with this map's comparator (or, if the map has no comparator,&#xA; if {@code fromKey} does not implement {@link Comparable}).&#xA; Implementations may, but are not required to, throw this&#xA; exception if {@code fromKey} cannot be compared to keys&#xA; currently in the map.
+   * @throws NullPointerException if {@code fromKey} is null&#xA; and this map does not permit null keys
+   * @throws IllegalArgumentException if this map itself has a&#xA; restricted range, and {@code fromKey} lies outside the&#xA; bounds of the range
+   */
+  tailMap(fromKey: unknown, inclusive: boolean): NavigableMap;
+
+  /**
+   * {@inheritDoc}
+   *
+   *  <p>Equivalent to {@code subMap(fromKey, true, toKey, false)}.
+   * @throws ClassCastException {@inheritDoc}
+   * @throws NullPointerException {@inheritDoc}
+   * @throws IllegalArgumentException {@inheritDoc}
+   */
+  subMap(fromKey: unknown, toKey: unknown): SortedMap;
+
+  /**
+   * {@inheritDoc}
+   *
+   *  <p>Equivalent to {@code headMap(toKey, false)}.
+   * @throws ClassCastException {@inheritDoc}
+   * @throws NullPointerException {@inheritDoc}
+   * @throws IllegalArgumentException {@inheritDoc}
+   */
+  headMap(toKey: unknown): SortedMap;
+
+  /**
+   * {@inheritDoc}
+   *
+   *  <p>Equivalent to {@code tailMap(fromKey, true)}.
+   * @throws ClassCastException {@inheritDoc}
+   * @throws NullPointerException {@inheritDoc}
+   * @throws IllegalArgumentException {@inheritDoc}
+   */
+  tailMap(fromKey: unknown): SortedMap;
+};

package/types/java/util/NavigableMap/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  lowerEntry: function lowerEntry() {},
+  lowerKey: function lowerKey() {},
+  floorEntry: function floorEntry() {},
+  floorKey: function floorKey() {},
+  ceilingEntry: function ceilingEntry() {},
+  ceilingKey: function ceilingKey() {},
+  higherEntry: function higherEntry() {},
+  higherKey: function higherKey() {},
+  firstEntry: function firstEntry() {},
+  lastEntry: function lastEntry() {},
+  pollFirstEntry: function pollFirstEntry() {},
+  pollLastEntry: function pollLastEntry() {},
+  descendingMap: function descendingMap() {},
+  navigableKeySet: function navigableKeySet() {},
+  descendingKeySet: function descendingKeySet() {},
+  subMap: function subMap() {},
+  headMap: function headMap() {},
+  tailMap: function tailMap() {}
+};
+exports["default"] = _default;