@juun-roh/cesium-utils 0.0.6 → 0.0.8

package/dist/collection/index.d.ts

@@ -49,8 +49,7 @@ type NonFunction<T> = {
  * entities.add(new Entity({ ... }), 'roads');
  *
  * // Later, show only buildings
- * entities.show('buildings');
- * entities.hide('roads');
+ * entities.show('buildings').hide('roads');
  */
 declare class Collection<C extends CesiumCollection, I extends CesiumCollectionItem> {
     /**
@@ -95,6 +94,22 @@ declare class Collection<C extends CesiumCollection, I extends CesiumCollectionI
         collection: C;
         tag?: Tag;
     });
+    /**
+     * Makes the collection directly iterable, allowing it to be used in `for...of` loops
+     * and with spread operators.
+     *
+     * @returns An iterator for the items in the collection
+     *
+     * @example
+     * // Iterate through all items in the collection
+     * for (const entity of collection) {
+     *   console.log(entity.id);
+     * }
+     *
+     * // Convert collection to array using spread syntax
+     * const entitiesArray = [...collection];
+     */
+    [Symbol.iterator](): Iterator<I>;
     /**
      * Emits an event to all registered listeners.
      *
@@ -168,10 +183,22 @@ declare class Collection<C extends CesiumCollection, I extends CesiumCollectionI
     /**
      * Returns true if the provided item is in this collection, false otherwise.
      *
-     * @param item - The item to check for
+     * @param item - The item instance to check for
      * @returns True if the item is in the collection, false otherwise
      */
     contains(item: I): boolean;
+    /**
+     * Checks if the collection has any items with the specified tag.
+     *
+     * @param tag - The tag to check for
+     * @returns True if items with the tag exist, false otherwise
+     *
+     * @example
+     * if (collection.contains('temporary')) {
+     *   console.log('Temporary items exist');
+     * }
+     */
+    contains(tag: Tag): boolean;
     /**
      * Removes an item from the collection.
      *
@@ -179,6 +206,20 @@ declare class Collection<C extends CesiumCollection, I extends CesiumCollectionI
      * @returns True if the item was removed, false if it wasn't found
      */
     remove(item: I): boolean;
+    /**
+     * Removes all items with the specified tag from the collection.
+     *
+     * @param by - The tag identifying which items to remove
+     * @returns True if the item was removed, false if it wasn't found
+     */
+    remove(by: Tag): boolean;
+    /**
+     * Removes all items with the array of tags from the collection.
+     *
+     * @param by - The tags identifying which items to remove
+     * @returns True if the item was removed, false if it wasn't found
+     */
+    remove(by: Tag[]): boolean;
     /**
      * Removes all items from the collection.
      */
@@ -200,26 +241,26 @@ declare class Collection<C extends CesiumCollection, I extends CesiumCollectionI
      * Gets all items with the specified tag from the collection.
      * Uses an optimized internal map for faster lookups.
      *
-     * @param tag - The tag to filter by
+     * @param by - The tag to filter by
      * @returns An array of items with the specified tag, or an empty array if none found
      *
      * @example
      * // Get all buildings
-     * const buildings = collection.getByTag('buildings');
+     * const buildings = collection.get('buildings');
      */
-    getByTag(tag: Tag): I[];
+    get(by: Tag): I[];
     /**
-     * Gets the first item matching the tag. More efficient than getByTag when
+     * Gets the first item matching the tag. More efficient than `get` when
      * you only need one item, especially for large collections.
      *
-     * @param tag - The tag to search for
+     * @param by - The tag to search for
      * @returns The first matching item or undefined if none found
      *
      * @example
      * // Get the first building
-     * const firstBuilding = collection.getFirstByTag('buildings');
+     * const firstBuilding = collection.first('buildings');
      */
-    getFirstByTag(tag: Tag): I | undefined;
+    first(by: Tag): I | undefined;
     /**
      * Gets all unique tags currently in use in the collection.
      *
@@ -227,99 +268,63 @@ declare class Collection<C extends CesiumCollection, I extends CesiumCollectionI
      *
      * @example
      * // Get all tags
-     * const tags = collection.getTags();
+     * const tags = collection.tags;
      * console.log(`Collection has these tags: ${tags.join(', ')}`);
      */
-    getTags(): Tag[];
-    /**
-     * Checks if the collection has any items with the specified tag.
-     *
-     * @param tag - The tag to check for
-     * @returns True if items with the tag exist, false otherwise
-     *
-     * @example
-     * if (collection.hasTag('temporary')) {
-     *   console.log('Temporary items exist');
-     * }
-     */
-    hasTag(tag: Tag): boolean;
+    get tags(): Tag[];
     /**
      * Updates the tag for all items with the specified tag.
      *
-     * @param oldTag - The tag to replace
-     * @param newTag - The new tag to assign
+     * @param from - The tag to replace
+     * @param to - The new tag to assign
      * @returns The number of items updated
      *
      * @example
      * // Rename a tag
-     * const count = collection.updateTag('temp', 'temporary');
+     * const count = collection.update('temp', 'temporary');
      * console.log(`Updated ${count} items`);
      */
-    updateTag(oldTag: Tag, newTag: Tag): number;
-    /**
-     * Removes all items with the specified tag from the collection.
-     *
-     * @param tag - The tag identifying which items to remove
-     * @returns The number of items removed
-     *
-     * @example
-     * // Remove all temporary markers
-     * const count = collection.removeByTag('temporary');
-     * console.log(`Removed ${count} items`);
-     */
-    removeByTag(tag: Tag): number;
-    /**
-     * Removes all items with the array of tags from the collection.
-     *
-     * @param tag - The tags identifying which items to remove
-     * @returns The number of items removed
-     *
-     * @example
-     * // Remove all items containing tags
-     * const count = collection.removeByTag('temporary', 'default', 'tag');
-     * console.log(`Removed ${count} items`);
-     */
-    removeByTag(tag: Tag[]): number;
+    update(from: Tag, to: Tag): number;
     /**
      * Makes all items with the specified tag visible.
      * Only affects items that have a 'show' property.
      *
-     * @param tag - The tag identifying which items to show
-     * @returns The number of items affected
+     * @param by - The tag identifying which items to show
+     * @returns The collection itself.
      *
      * @example
      * // Show all buildings
      * collection.show('buildings');
      */
-    show(tag: Tag): number;
+    show(by: Tag): this;
     /**
      * Hides all items with the specified tag.
      * Only affects items that have a 'show' property.
      *
-     * @param tag - The tag identifying which items to hide
-     * @returns The number of items affected
+     * @param by - The tag identifying which items to hide
+     * @returns The collection itself.
      *
      * @example
      * // Hide all buildings
      * collection.hide('buildings');
      */
-    hide(tag: Tag): number;
+    hide(by: Tag): this;
     /**
      * Toggles visibility of all items with the specified tag.
      * Only affects items that have a 'show' property.
      *
-     * @param tag - The tag identifying which items to toggle
-     * @returns The number of items affected
+     * @param by - The tag identifying which items to toggle
+     * @returns The collection itself.
      *
      * @example
      * // Toggle visibility of all buildings
      * collection.toggle('buildings');
      */
-    toggle(tag: Tag): number;
+    toggle(by: Tag): this;
     /**
      * Sets a property value on all items with the specified tag.
      *
-     * @param tag - The tag identifying which items to update
+     * @param by - The tag identifying which items to update
      * @param property - The property name to set
      * @param value - The value to set
      * @returns The number of items updated
@@ -328,13 +333,13 @@ declare class Collection<C extends CesiumCollection, I extends CesiumCollectionI
      * // Change color of all buildings to red
      * collection.setProperty('buildings', 'color', Color.RED);
      */
-    setProperty<K extends NonFunction<I>, V extends Exclude<I[K], Function>>(property: K, value: V, tag?: Tag): number;
+    setProperty<K extends NonFunction<I>, V extends Exclude<I[K], Function>>(property: K, value: V, by?: Tag): this;
     /**
      * Filters items in the collection based on a predicate function.
      * Optionally only filters items with a specific tag.
      *
      * @param predicate - Function that tests each item
-     * @param tag - Optional tag to filter by before applying the predicate
+     * @param by - Optional tag to filter by before applying the predicate
      * @returns Array of items that pass the test
      *
      * @example
@@ -344,13 +349,13 @@ declare class Collection<C extends CesiumCollection, I extends CesiumCollectionI
      *   'buildings'
      * );
      */
-    filter(predicate: (item: I) => boolean, tag?: Tag): I[];
+    filter(predicate: (item: I) => boolean, by?: Tag): I[];
     /**
      * Executes a callback function for each item in the collection.
      * Optionally filters items by tag before execution.
      *
      * @param callback - Function to execute for each item
-     * @param tag - Optional tag to filter items (if not provided, processes all items)
+     * @param by - Optional tag to filter items (if not provided, processes all items)
      *
      * @example
      * // Highlight all buildings
@@ -360,7 +365,45 @@ declare class Collection<C extends CesiumCollection, I extends CesiumCollectionI
      *   }
      * }, 'buildings');
      */
-    forEach(callback: (item: I, index: number) => void, tag?: Tag): void;
+    forEach(callback: (value: I, index: number) => void, by?: Tag): void;
+    /**
+     * Creates a new array with the results of calling a provided function on every element
+     * in the collection. Optionally filters by tag before mapping.
+     *
+     * @param callbackfn - Function that produces an element of the new array
+     * @param by - Optional tag to filter items by before mapping
+     * @returns A new array with each element being the result of the callback function
+     *
+     * @example
+     * // Get all entity IDs
+     * const entityIds = collection.map(entity => entity.id);
+     *
+     * // Get positions of all buildings
+     * const buildingPositions = collection.map(
+     *   entity => entity.position.getValue(Cesium.JulianDate.now()),
+     *   'buildings'
+     * );
+     */
+    map<R>(callbackfn: (value: I, index: number) => R, by?: Tag): R[];
+    /**
+     * Returns the first element in the collection that satisfies the provided testing function.
+     * Optionally filters by tag before searching.
+     *
+     * @param predicate - Function to test each element
+     * @param by - Optional tag to filter items by before searching
+     * @returns The first element that passes the test, or undefined if no elements pass
+     *
+     * @example
+     * // Find the first entity with a specific name
+     * const namedEntity = collection.find(entity => entity.name === 'Target');
+     *
+     * // Find the first building taller than 100 meters
+     * const tallBuilding = collection.find(
+     *   entity => entity.properties?.height?.getValue() > 100,
+     *   'buildings'
+     * );
+     */
+    find(predicate: (value: I) => boolean, by?: Tag): I | undefined;
 }
 
 export { type CesiumCollection, type CesiumCollectionItem, Collection, type CollectionEventType, type EventHandler, type NonFunction, type Tag, type WithTag };

package/dist/collection/index.js

@@ -1 +1 @@
-import{c as o}from"../chunk-HC6YX7RQ.js";import"../chunk-YZ7AUGIO.js";export{o as Collection};
+import{c as o}from"../chunk-DOPMSVYJ.js";import"../chunk-YZ7AUGIO.js";export{o as Collection};

package/dist/{hybrid-terrain-provider-C6aXdtyo.d.cts → hybrid-terrain-provider-Cp_rA9j4.d.cts}

@@ -1,4 +1,4 @@
-import { TilingScheme, TerrainProvider, Rectangle, Request, TerrainData, Credit, TileAvailability } from 'cesium';
+import { Request, TerrainData, Credit, TerrainProvider, Rectangle, CesiumTerrainProvider, TilingScheme, TileAvailability } from 'cesium';
 
 /** A range of tiles from `start` to `end` */
 type TileRange = {
@@ -13,90 +13,6 @@ type TileRange = {
         y: number;
     };
 };
-/** A `TileRange` map with specific levels as their keys. */
-type TileRanges = Map<number, TileRange>;
-
-/**
- * @class
- * Defines the geographic boundaries for a terrain area and handles tile availability checks.
- */
-declare class TerrainBounds {
-    private _rectangle;
-    private _tilingScheme;
-    private _tileRanges;
-    private _levels;
-    /**
-     * Creates a new instance of TerrainBounds.
-     * @param options {@link TerrainBounds.ConstructorOptions}
-     * @param tilingScheme (optional) The tiling scheme to use for coordinate calculations.
-     */
-    constructor(options: TerrainBounds.ConstructorOptions, tilingScheme?: TilingScheme);
-    /**
-     * Checks if the specified tile coordinates are within the bounds.
-     * @param x The tile X coordinate.
-     * @param y The tile Y coordinate.
-     * @param level The tile level.
-     * @returns `true` if the tile is within bounds, `false` otherwise.
-     */
-    contains(x: number, y: number, level: number): boolean;
-    /**
-     *
-     * Configures a terrain provider's availability based on these bounds.
-     * @see WARNING This method is accessing private property of {@link https://cesium.com/learn/csiumjs/ref-doc/TileAvailability.html `TileAvailability`}.
-     * @param provider The terrain provider to configure.
-     */
-    configureAvailability(provider: TerrainProvider): void;
-    /**
-     * Gets the rectangle representing these bounds.
-     */
-    get rectangle(): Rectangle;
-    /** Gets the tiling scheme used by these bounds. */
-    get tilingScheme(): TilingScheme;
-    /** Gets the tile ranges defined for these bounds. */
-    get tileRanges(): TileRanges;
-    /** Gets the levels for which tile ranges are defined. */
-    get levels(): Set<number>;
-    /**
-     * Calculates a bounding rectangle that encompasses all the specified tile ranges.
-     * @private
-     */
-    private _calculateRectangleFromTileRanges;
-}
-/**
- * @namespace
- * Contains types and factory methods for creating `TerrainBounds` instances.
- */
-declare namespace TerrainBounds {
-    /** Initialization options for Terrain Bounds constructor */
-    interface ConstructorOptions {
-        /** Type of bounds definition. */
-        type: 'tileRange' | 'rectangle';
-        /**
-         * Tile ranges by level when using tileRange type.
-         * Keys are zoom levels, values define the range of tiles at that level.
-         * Can be provided either as a Map or as a plain object with numeric keys.
-         */
-        tileRanges?: Map<number, TileRange> | Record<string | number, TileRange>;
-        /** Rectangle bounds when using rectangle type. */
-        rectangle?: Rectangle;
-    }
-    /**
-     * Creates `TerrainBounds` from tile coordinates at a specific level.
-     * @param x The tile X coordinate.
-     * @param y The tile Y coordinate.
-     * @param level The tile level.
-     * @param tilingScheme The tiling scheme to use.
-     * @returns A new `TerrainBounds` instance for the specified tile.
-     */
-    function fromTile(x: number, y: number, level: number, tilingScheme?: TilingScheme): TerrainBounds;
-    /**
-     * Creates `TerrainBounds` from a rectangle.
-     * @param rectangle The rectangle defining the bounds.
-     * @param tilingScheme The tiling scheme to use.
-     * @returns A new `TerrainBounds` instance for the specified rectangle.
-     */
-    function fromRectangle(rectangle: Rectangle, tilingScheme?: TilingScheme): TerrainBounds;
-}
 
 /**
  * @class
@@ -105,25 +21,22 @@ declare namespace TerrainBounds {
  */
 declare class TerrainArea {
     private _provider;
-    private _bounds;
-    private _levels;
+    private _rectangle;
+    private _tileRanges;
     private _ready;
     private _credit;
     private _isCustom;
     /**
      * Creates a new instance of `TerrainArea`.
      * @param options Object describing initialization options
-     * @private Use {@link TerrainArea.create} instead.
      */
-    private constructor();
+    constructor(options: TerrainArea.ConstructorOptions);
     /**
-     * Asynchronously creates a new instance of `TerrainArea`.
-     * @param options {@link TerrainArea.ConstructorOptions}
-     * @returns A promise that resolves to a new `TerrainArea` instance.
-     */
-    static create(options: TerrainArea.ConstructorOptions): Promise<TerrainArea>;
-    /**
-     * @see {@link TerrainBounds.contains}
+     * Checks if the specified tile coordinates are within the bounds.
+     * @param x The tile X coordinate.
+     * @param y The tile Y coordinate.
+     * @param level The tile level.
+     * @returns `true` if the tile is within bounds, `false` otherwise.
      */
     contains(x: number, y: number, level: number): boolean;
     /**
@@ -151,11 +64,11 @@ declare class TerrainArea {
     /** Gets the credit associated with this terrain area. */
     get credit(): string | Credit;
     /** Gets the terrain provider for this terrain area. */
-    get provider(): TerrainProvider | undefined;
-    /** Gets the terrain bounds for this terrain area. */
-    get bounds(): TerrainBounds;
-    /** Gets available zoom levels set with this terrain area. */
-    get levels(): Set<number>;
+    get provider(): TerrainProvider;
+    /** Gets available tile ranges with zoom levels set with this terrain area. */
+    get tileRanges(): Map<number, TileRange>;
+    /** Gets the rectangle representing this terrain area. */
+    get rectangle(): Rectangle;
     /** Gets if this terrain area is ready. */
     get ready(): boolean;
 }
@@ -167,14 +80,12 @@ declare namespace TerrainArea {
     /** Initialization options for `TerrainArea` constructor. */
     interface ConstructorOptions {
         /** The terrain provider for this area or a URL to create one from. */
-        provider: TerrainProvider | string;
-        /** The geographic bounds of this terrain area. */
-        bounds: TerrainBounds | TerrainBounds.ConstructorOptions;
+        provider: TerrainProvider;
         /**
-         * The zoom levels this terrain area applies to.
-         * If empty, the area applies to all levels.
+         * Tile ranges by level when using tileRange type.
+         * Keys are zoom levels, values define the range of tiles at that level.
          */
-        levels?: number[];
+        tileRanges: Map<number, TileRange>;
         /**
          * Credit to associate with this terrain provider.
          * Used to identify custom terrain providers.
@@ -191,11 +102,10 @@ declare namespace TerrainArea {
      * Creates a `TerrainArea` from a URL and tile ranges.
      * @param url The URL to create the terrain provider from.
      * @param tileRanges Tile ranges by level.
-     * @param levels The zoom levels this area applies to.
-     * @param credit Credit to associate with this terrain provider.
+     * @param options: Constructor options for CesiumTerrainProvider.
      * @returns A promise resolving to a new `TerrainArea`
      */
-    function fromUrl(url: string, tileRanges: TileRanges, levels?: number[], credit?: string | Credit): Promise<Awaited<TerrainArea>>;
+    function fromUrl(url: string, tileRanges: Map<number, TileRange>, options?: CesiumTerrainProvider.ConstructorOptions): Promise<Awaited<TerrainArea>>;
 }
 
 /**
@@ -336,10 +246,9 @@ declare namespace HybridTerrainProvider {
      * @param customTerrainUrl URL to the custom terrain.
      * @param baseTerrainUrl URL to the base terrain.
      * @param tileRanges Tile ranges defining the custom terrain area.
-     * @param levels Levels to apply the custom terrain.
      * @returns A promise resolving to a new `HybridTerrainProvider`.
      */
-    function createOverlay(customTerrainUrl: string, baseTerrainUrl: string, tileRanges: TileRanges, levels?: number[]): Promise<Awaited<HybridTerrainProvider>>;
+    function createOverlay(customTerrainUrl: string, baseTerrainUrl: string, tileRanges: Map<number, TileRange>): Promise<Awaited<HybridTerrainProvider>>;
 }
 
-export { HybridTerrainProvider as H, TerrainArea as T, TerrainBounds as a, type TileRange as b, type TileRanges as c };
+export { HybridTerrainProvider as H, TerrainArea as T, type TileRange as a };