@sswroom/sswr 1.5.3 → 1.5.5

package/Changelog

@@ -1,3 +1,23 @@
+1.5.5
+-Fixed web.Dialog in iframe
+-Fixed GeolocationFilter when using minDistMeter
+-Added data.ByteReader
+-Added media.StaticImage
+-Added media.EXIFData
+-Added media.loadImageFromBlob
+-Added text.u8Arr2Hex
+-Added web.propertiesToHTML
+-Support parsing JPG file
+-Support parsing WEBP file
+-web.openData Support Blob
+
+1.5.4
+-Added geometry.Vector2D.getBounds
+-Added kml.Feature.getBounds
+-Added leaflet.toLatLngBounds
+-Added math.RectArea.unionInPlace
+-Added math.RectArea.unionPointInPlace
+
 1.5.3
 -Fixed parser file type handling
 

package/cesium.js

@@ -462,8 +462,21 @@ export class CesiumMap extends map.MapControl
 	{
 		this.viewer.camera.flyTo({destination: Cesium.Cartesian3.fromDegrees(pos.x, pos.y, scale), duration:0});
 	}
-/*	zoomToExtent(extent: math.RectArea): void;
-	handleMouseLClick(clickFunc: (mapPos: math.Coord2D, scnPos: math.Coord2D)=>void): void;
+
+	zoomToExtent(extent)
+	{
+		const zoomRatio = 500000000;
+		let center = extent.getCenter();
+		let xScale = (extent.max.x - extent.min.x) / this.viewer.canvas.width * zoomRatio;
+		let yScale = (extent.max.y - extent.min.y) / this.viewer.canvas.height * zoomRatio;
+		if (yScale > xScale)
+		{
+			xScale = yScale;
+		}
+		this.viewer.camera.flyTo({destination: Cesium.Cartesian3.fromDegrees(center.x, center.y, xScale), duration:0});
+	}
+
+/*	handleMouseLClick(clickFunc: (mapPos: math.Coord2D, scnPos: math.Coord2D)=>void): void;
 	handleMouseMove(moveFunc: (mapPos: math.Coord2D)=>void): void;
 	handlePosChange(posFunc: (mapPos: math.Coord2D)=>void): void;
 	map2ScnPos(mapPos: math.Coord2D): math.Coord2D;

package/data.d.ts

@@ -176,3 +176,30 @@ export class Timestamp {
 	toTimeValue(): TimeValue;
 	roundToS(): Timestamp;
 }
+
+export class ByteReader
+{
+	view: DataView;
+
+	constructor(arr: ArrayBuffer);
+	getLength(): number;
+	getArrayBuffer(ofst: number, size: number): ArrayBuffer;
+
+	readUInt8(ofst: number): number;
+	readUInt16(ofst: number, lsb: boolean): number;
+	readUInt32(ofst: number, lsb: boolean): number;
+	readInt8(ofst: number): number;
+	readInt16(ofst: number, lsb: boolean): number;
+	readInt32(ofst: number, lsb: boolean): number;
+	readFloat64(ofst: number, lsb: boolean): number;
+	readUTF8(ofst: number, len: number): string;
+	readUTF8Z(ofst: number, maxSize?: number): string;
+
+	readUInt8Arr(ofst: number, cnt: number): number[];
+	readUInt16Arr(ofst: number, lsb: boolean, cnt: number): number[];
+	readUInt32Arr(ofst: number, lsb: boolean, cnt: number): number[];
+	readInt8Arr(ofst: number, cnt: number): number[];
+	readInt16Arr(ofst: number, lsb: boolean, cnt: number): number[];
+	readInt32Arr(ofst: number, lsb: boolean, cnt: number): number[];
+	readFloat64Arr(ofst: number, lsb: boolean, cnt: number): number[];
+}

package/data.js

@@ -2292,3 +2292,163 @@ export class Timestamp
 		return new Timestamp(this.inst.roundToS(), this.tzQhr);
 	}
 }
+
+export class ByteReader
+{
+	constructor(arr)
+	{
+		this.view = new DataView(arr);
+	}
+
+	getLength()
+	{
+		return this.view.byteLength;
+	}
+
+	getArrayBuffer(ofst, size)
+	{
+		if (ofst == null)
+			ofst = 0;
+		if (size == null)
+			size = this.view.byteLength - ofst;
+		return this.view.buffer.slice(this.view.byteOffset + ofst, this.view.byteOffset + ofst + size);
+	}
+
+	readUInt8(ofst)
+	{
+		return this.view.getUint8(ofst);
+	}
+
+	readUInt16(ofst, lsb)
+	{
+		return this.view.getUint16(ofst, lsb);
+	}
+
+	readUInt32(ofst, lsb)
+	{
+		return this.view.getUint32(ofst, lsb);
+	}
+
+	readInt8(ofst)
+	{
+		return this.view.getInt8(ofst);
+	}
+
+	readInt16(ofst, lsb)
+	{
+		return this.view.getInt16(ofst, lsb);
+	}
+
+	readInt32(ofst, lsb)
+	{
+		return this.view.getInt32(ofst, lsb);
+	}
+
+	readFloat64(ofst, lsb)
+	{
+		return this.view.getFloat64(ofst, lsb);
+	}
+
+	readUTF8(ofst, len)
+	{
+		let dec = new TextDecoder();
+		return dec.decode(this.getArrayBuffer(ofst, len));
+	}
+
+	readUTF8Z(ofst, maxSize)
+	{
+		let end = ofst;
+		let maxEnd;
+		if (maxSize)
+		{
+			maxEnd = ofst + maxSize;
+			if (maxEnd > this.view.byteLength)
+				maxEnd = this.view.byteLength;
+		}
+		else
+		{
+			maxEnd = this.view.byteLength;
+		}
+		while (end < maxEnd && this.view.getUint8(end) != 0)
+			end++;
+		let dec = new TextDecoder();
+		return dec.decode(this.view.buffer.slice(this.view.byteOffset + ofst, this.view.byteOffset + end));
+	}
+
+	readUInt8Arr(ofst, cnt)
+	{
+		let ret = [];
+		while (cnt-- > 0)
+		{
+			ret.push(this.readUInt8(ofst));
+			ofst++;
+		}
+		return ret;
+	}
+
+	readUInt16Arr(ofst, lsb, cnt)
+	{
+		let ret = [];
+		while (cnt-- > 0)
+		{
+			ret.push(this.readUInt16(ofst, lsb));
+			ofst += 2;
+		}
+		return ret;
+	}
+
+	readUInt32Arr(ofst, lsb, cnt)
+	{
+		let ret = [];
+		while (cnt-- > 0)
+		{
+			ret.push(this.readUInt32(ofst, lsb));
+			ofst += 4;
+		}
+		return ret;
+	}
+
+	readInt8Arr(ofst, cnt)
+	{
+		let ret = [];
+		while (cnt-- > 0)
+		{
+			ret.push(this.readInt8(ofst));
+			ofst++;
+		}
+		return ret;
+	}
+
+	readInt16Arr(ofst, lsb, cnt)
+	{
+		let ret = [];
+		while (cnt-- > 0)
+		{
+			ret.push(this.readInt16(ofst, lsb));
+			ofst += 2;
+		}
+		return ret;
+	}
+
+	readInt32Arr(ofst, lsb, cnt)
+	{
+		let ret = [];
+		while (cnt-- > 0)
+		{
+			ret.push(this.readInt32(ofst, lsb));
+			ofst += 4;
+		}
+		return ret;
+	}
+
+	readFloat64Arr(ofst, lsb, cnt)
+	{
+		let ret = [];
+		while (cnt-- > 0)
+		{
+			ret.push(this.readFloat64(ofst, lsb));
+			ofst += 8;
+		}
+		return ret;
+	}
+}

package/geometry.d.ts

@@ -40,6 +40,7 @@ export class Vector2D {
 	type: VectorType;
 	constructor(srid: number);
 	insideOrTouch(coord: math.Coord2D): boolean;
+	getBounds(): math.RectArea;
 };
 
 export class Point extends Vector2D
@@ -47,6 +48,7 @@ export class Point extends Vector2D
 	coordinates: number[];
 	constructor(srid: number, coordinates: number[] | math.Coord2D | math.Vector3);
 	insideOrTouch(coord: math.Coord2D): boolean;
+	getBounds(): math.RectArea;
 }
 
 
@@ -56,6 +58,7 @@ export class LineString extends Vector2D
 	constructor(srid: number, coordinates: number[][]);
 	calBoundaryPoint(coord: math.Coord2D): BoundaryPointResult;
 	insideOrTouch(coord: math.Coord2D): boolean;
+	getBounds(): math.RectArea;
 }
 
 export class LinearRing extends LineString
@@ -76,6 +79,7 @@ export class MultiGeometry<VecType> extends Vector2D
 	constructor(srid: number);
 	calBoundaryPoint(coord: math.Coord2D): BoundaryPointResult;
 	insideOrTouch(coord: math.Coord2D): boolean;
+	getBounds(): math.RectArea;
 }
 
 export class Polygon extends MultiGeometry<LinearRing>

package/geometry.js

@@ -52,6 +52,11 @@ export class Point extends Vector2D
 	{
 		return this.coordinates[0] == coord.x && this.coordinates[1] == coord.y;
 	}
+
+	getBounds()
+	{
+		return new math.RectArea(this.coordinates[0], this.coordinates[1], this.coordinates[0], this.coordinates[1]);
+	}
 }
 
 export class LineString extends Vector2D
@@ -226,6 +231,17 @@ export class LineString extends Vector2D
 		}
 		return false;
 	}
+
+	getBounds()
+	{
+		let bounds = new math.RectArea(this.coordinates[0][0], this.coordinates[0][1], this.coordinates[0][0], this.coordinates[0][1]);
+		let i;
+		for (i in this.coordinates)
+		{
+			bounds.unionPointInPlace(this.coordinates[i][0], this.coordinates[i][1]);
+		}
+		return bounds;
+	}
 }
 
 export class LinearRing extends LineString
@@ -364,6 +380,29 @@ export class MultiGeometry extends Vector2D
 		}
 		return false;
 	}
+
+	getBounds()
+	{
+		if (this.geometries.length == 0)
+		{
+			return null;
+		}
+		let bounds;
+		let thisBounds;
+		let i;
+		for (i in this.geometries)
+		{
+			thisBounds = this.geometries[i].getBounds();
+			if (thisBounds)
+			{
+				if (bounds)
+					bounds.unionInPlace(thisBounds);
+				else
+					bounds = thisBounds;
+			}
+		}
+		return bounds;
+	}
 }
 
 export class Polygon extends MultiGeometry

package/kml.d.ts

@@ -1,5 +1,6 @@
 import * as data from "./data";
 import * as geometry from "./geometry";
+import * as math from "./math";
 import * as web from "./web";
 
 export enum AltitudeMode
@@ -40,6 +41,21 @@ export enum HotSpotUnit
 	InsetPixels
 };
 
+export enum RefreshMode
+{
+	OnChange,
+	OnInterval,
+	OnExpire
+};
+
+export enum ViewRefreshMode
+{
+	Never,
+	OnStop,
+	OnRequest,
+	OnRegion
+};
+
 export class Element
 {
 	getUsedNS(ns: object): void;
@@ -214,6 +230,7 @@ export class Feature extends Element
 	visibility: boolean;
 	open: boolean;
 	author: string;
+	authorName: string;
 	link: string;
 	address: string;
 	//AddressDetails: ?;
@@ -228,6 +245,7 @@ export class Feature extends Element
 	setVisibility(visibility: boolean): void;
 	setOpen(open: boolean): void;
 	setAuthor(author: string): void;
+	setAuthorName(authorName: string): void;
 	setLink(link: string): void;
 	setAddress(address: string): void;
 	setPhoneNumber(phoneNumber: string): void;
@@ -235,6 +253,7 @@ export class Feature extends Element
 	setDescription(description: string): void;
 	setLookAt(lookAt: LookAt): void;
 	setStyle(style: StyleSelector): void;
+	getBounds(): math.RectArea | null;
 
 	appendInnerXML(strs: string[], level: number): void;
 }
@@ -252,6 +271,7 @@ export class Container extends Feature
 	addStyleMap(styleMap: StyleMap): void;
 	getOrNewStyle(iconStyle: IconStyle, labelStyle: LabelStyle, lineStyle: LineStyle, polyStyle: PolyStyle, balloonStyle: BalloonStyle, listStyle: ListStyle): Style;
 	getStyleById(id: string): Style | StyleMap | null;
+	getBounds(): math.RectArea | null;
 	getUsedNS(ns: object): void;
 	appendOuterXML(strs: string[], level: number): void;
 }
@@ -268,8 +288,21 @@ export class Folder extends Container
 
 export class NetworkLink extends Feature
 {
-	constructor();
-
+	networkLink: string;
+	refreshVisibility: boolean;
+	flyToView: boolean;
+	refreshMode: RefreshMode;
+	refreshInterval: number;
+	viewRefreshMode: ViewRefreshMode;
+
+	constructor(networkLink: string);
+	setRefreshVisibility(refreshVisibility: boolean): void;
+	setFlyToView(flyToView: boolean): void;
+	setRefreshMode(refreshMode: RefreshMode): void;
+	setRefreshInterval(refreshInterval: number): void;
+	setViewRefreshMode(viewRefreshMode: ViewRefreshMode): void;
+
+	getBounds(): math.RectArea | null;
 	getUsedNS(ns: object): void;
 	appendOuterXML(strs: string[], level: number): void;
 }
@@ -280,6 +313,7 @@ export class Placemark extends Feature
 	constructor(vec: geometry.Vector2D);
 
 	appendGeometry(strs: string[], level: number, vec: geometry.Vector2D, subGeom?: boolean): void;
+	getBounds(): math.RectArea | null;
 	getUsedNS(ns: object): void;
 	appendOuterXML(strs: string[], level: number): void;
 }

package/kml.js

@@ -35,6 +35,19 @@ export const HotSpotUnit = {
 	InsetPixels: "insetPixels"
 }
 
+export const RefreshMode = {
+	OnChange: "onChange",
+	OnInterval: "onInterval",
+	OnExpire: "onExpire"
+};
+
+export const ViewRefreshMode = {
+	Never: "never",
+	OnStop: "onStop",
+	OnRequest: "onRequest",
+	OnRegion: "onRegion"
+};
+
 export class Element
 {
 }
@@ -655,6 +668,11 @@ export class Feature extends Element
 		this.author = author;
 	}
 
+	setAuthorName(authorName)
+	{
+		this.authorName = authorName;
+	}
+
 	setLink(link)
 	{
 		this.link = link;
@@ -698,8 +716,12 @@ export class Feature extends Element
 			strs.push("\t".repeat(level)+"<visibility>"+(this.visibility?"1":"0")+"</visibility>");
 		if (this.open != null)
 			strs.push("\t".repeat(level)+"<open>"+(this.open?"1":"0")+"</open>");
-		if (this.author)
+		if (this.author && this.authorName)
+			strs.push("\t".repeat(level)+"<atom:author>"+text.toXMLText(this.author)+"<atom:name>"+text.toXMLText(this.authorName)+"</atom:name></atom:author>");
+		else if (this.author)
 			strs.push("\t".repeat(level)+"<atom:author>"+text.toXMLText(this.author)+"</atom:author>");
+		else if (this.authorName)
+			strs.push("\t".repeat(level)+"<atom:author><atom:name>"+text.toXMLText(this.authorName)+"</atom:name></atom:author>");
 		if (this.link)
 			strs.push("\t".repeat(level)+"<atom:link href="+text.toAttrText(this.link)+"/>");
 		if (this.address)
@@ -790,6 +812,29 @@ export class Container extends Feature
 		return null;
 	}
 
+	getBounds()
+	{
+		let bounds = null;
+		let thisBounds;
+		let i;
+		for (i in this.features)
+		{
+			thisBounds = this.features[i].getBounds();
+			if (thisBounds)
+			{
+				if (bounds)
+				{
+					bounds = bounds.unionInPlace(thisBounds);
+				}
+				else
+				{
+					bounds = thisBounds;
+				}
+			}
+		}
+		return bounds;
+	}
+
 	getUsedNS(ns)
 	{
 		if (this.styleList)
@@ -845,6 +890,70 @@ export class Folder extends Container
 	}
 }
 
+export class NetworkLink extends Feature
+{
+	constructor(networkLink)
+	{
+		super();
+		this.networkLink = networkLink;
+	}
+
+	setRefreshVisibility(refreshVisibility)
+	{
+		this.refreshVisibility = refreshVisibility;
+	}
+
+	setFlyToView(flyToView)
+	{
+		this.flyToView = flyToView;
+	}
+
+	setRefreshMode(refreshMode)
+	{
+		this.refreshMode = refreshMode;
+	}
+
+	setRefreshInterval(refreshInterval)
+	{
+		this.refreshInterval = refreshInterval;
+	}
+
+	setViewRefreshMode(viewRefreshMode)
+	{
+		this.viewRefreshMode = viewRefreshMode;
+	}
+
+	getBounds()
+	{
+		return null;
+	}
+
+	getUsedNS(ns)
+	{
+	}
+
+	appendOuterXML(strs, level)
+	{
+		strs.push("\t".repeat(level)+"<NetworkLink>");
+		this.appendInnerXML(strs, level + 1);
+		if (this.refreshVisibility != null)
+			strs.push("\t".repeat(level + 1)+"<refreshVisibility>"+(this.refreshVisibility?"1":"0")+"</refreshVisibility>");
+		if (this.flyToView != null)
+			strs.push("\t".repeat(level + 1)+"<flyToView>"+(this.flyToView?"1":"0")+"</flyToView>");
+
+		strs.push("\t".repeat(level + 1)+"<Link>");
+		strs.push("\t".repeat(level + 2)+"<href>"+text.toXMLText(this.networkLink)+"</href>");
+		if (this.refreshMode)
+			strs.push("\t".repeat(level + 2)+"<refreshMode>"+text.toXMLText(this.refreshMode)+"</refreshMode>");
+		if (this.refreshInterval)
+			strs.push("\t".repeat(level + 2)+"<refreshInterval>"+this.refreshInterval+"</refreshInterval>");
+		if (this.viewRefreshMode)
+			strs.push("\t".repeat(level + 2)+"<viewRefreshMode>"+text.toXMLText(this.viewRefreshMode)+"</viewRefreshMode>");
+		strs.push("\t".repeat(level + 1)+"</Link>");
+		strs.push("\t".repeat(level)+"</NetworkLink>");
+	}
+}
+
 export class Placemark extends Feature
 {
 	constructor(vec)
@@ -977,8 +1086,21 @@ export class Placemark extends Feature
 		}
 	}
 
+	getBounds()
+	{
+		if (this.vec)
+		{
+			return this.vec.getBounds();
+		}
+		return null;
+	}
+
 	getUsedNS(ns)
 	{
+		if (this.author || this.link || this.authorName)
+		{
+			ns.atom = "http://www.w3.org/2005/Atom";
+		}
 	}
 
 	appendOuterXML(strs, level)

package/leaflet.d.ts

@@ -1,7 +1,7 @@
 import * as L from "./node_modules/leaflet/src/Leaflet";
 import * as geometry from "./geometry";
 import * as kml from "./kml";
-import { Coord2D, RectArea } from "./math";
+import * as math from "./math";
 import * as map from "./map";
 
 declare class GeometryOptions
@@ -15,9 +15,11 @@ declare class KMLFeatureOptions
 	noPopup: boolean;
 }
 
-export function fromLatLon(latLon: L.LatLng): Coord2D;
-export function fromLatLng(latLng: L.LatLng): Coord2D;
-export function fromLatLngBounds(b: L.LatLngBounds): RectArea;
+export function fromLatLon(latLon: L.LatLng): math.Coord2D;
+export function fromLatLng(latLng: L.LatLng): math.Coord2D;
+export function fromLatLngBounds(b: L.LatLngBounds): math.RectArea;
+export function toLatLngBounds(rect: math.RectArea): L.LatLngBounds;
+
 export function createLayer(layer: map.LayerInfo, options: object): L.Layer;
 export function createFromKMLFeature(feature: kml.Feature, options: KMLFeatureOptions): L.Layer;
 export function createFromGeometry(geom: geometry.Vector2D, options: GeometryOptions): L.Layer;
@@ -25,6 +27,16 @@ export function createKMLLookAt(map: L.Map): kml.LookAt;
 export function toKMLFeature(layer: L.Layer, doc?: kml.Document): kml.Feature | null;
 export function toKMLString(layer: L.Layer): string | null;
 
+export class KMLNetworkLink
+{
+	feature: kml.NetworkLink;
+	container: L.FeatureGroup;
+
+	constructor(feature: kml.NetworkLink);
+	reload(): void;
+	addTo(container: L.FeatureGroup): KMLNetworkLink;
+}
+
 export class LeafletMap extends map.MapControl
 {
 	constructor(divId: string);