@sswroom/sswr 1.5.4 → 1.5.5

package/Changelog

@@ -1,3 +1,16 @@
+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

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/kml.d.ts

@@ -41,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;
@@ -215,6 +230,7 @@ export class Feature extends Element
 	visibility: boolean;
 	open: boolean;
 	author: string;
+	authorName: string;
 	link: string;
 	address: string;
 	//AddressDetails: ?;
@@ -229,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;
@@ -271,7 +288,19 @@ 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;

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)
@@ -868,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)
@@ -1011,6 +1097,10 @@ export class Placemark extends Feature
 
 	getUsedNS(ns)
 	{
+		if (this.author || this.link || this.authorName)
+		{
+			ns.atom = "http://www.w3.org/2005/Atom";
+		}
 	}
 
 	appendOuterXML(strs, level)

package/leaflet.d.ts

@@ -27,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);

package/leaflet.js

@@ -4,6 +4,7 @@ import * as kml from "./kml.js";
 import * as math from "./math.js";
 import * as map from "./map.js";
 import * as osm from "./osm.js";
+import * as parser from "./parser.js";
 import * as text from "./text.js";
 import * as web from "./web.js";
 
@@ -137,6 +138,10 @@ export function createFromKMLFeature(feature, options)
 		}
 		return layer;
 	}
+	else if (feature instanceof kml.NetworkLink)
+	{
+		return new KMLNetworkLink(feature);
+	}
 	else
 	{
 		console.log("Unknown KML feature type", feature);
@@ -441,6 +446,48 @@ export function toKMLString(layer)
 	return null;
 }
 
+export class KMLNetworkLink
+{
+	constructor(feature)
+	{
+		if (feature instanceof kml.NetworkLink)
+		{
+			this.feature = feature;
+			this.container = L.featureGroup();
+			this.reload();
+		}
+		else
+		{
+			throw new Error("Feature is not NetworkLink");
+		}
+	}
+
+	reload()
+	{
+		fetch(this.feature.networkLink).then((resp)=>{
+			console.log(resp);
+			if (resp.ok)
+			{
+				parser.parseFile(resp).then((val)=>{
+					console.log(val);
+					if (val instanceof kml.Feature)
+					{
+						this.container.clearLayers();
+						let layer = createFromKMLFeature(val);
+						if (layer)
+							layer.addTo(this.container);
+					}
+				})
+			}
+		})
+	}
+
+	addTo(container)
+	{
+		this.container.addTo(container);
+	}
+}
+
 export class LeafletMap extends map.MapControl
 {
 	constructor(divId)

package/map.js

@@ -134,7 +134,7 @@ export class GeolocationFilter
 		}
 		if (this.minDistMeter)
 		{
-			if (this.csys.calcSurfaceDistance(pos.coords.longitude, pos.coords.latitude, this.lastPos.longitude, this.lastPos.latitude, unit.Distance.Unit.METER) < this.minDistMeter)
+			if (this.csys.calcSurfaceDistance(pos.coords.longitude, pos.coords.latitude, this.lastPos.coords.longitude, this.lastPos.coords.latitude, unit.Distance.Unit.METER) < this.minDistMeter)
 				return false;
 		}
 

package/media.d.ts

@@ -0,0 +1,119 @@
+import * as data from "./data";
+
+export enum EXIFMaker
+{
+	Standard,
+	Panasonic,
+	Canon,
+	Olympus,
+	Casio1,
+	Casio2,
+	FLIR,
+	Nikon3,
+	Sanyo,
+	Apple
+};
+
+export enum EXIFType
+{
+	Unknown,
+	Bytes,
+	STRING,
+	UINT16,
+	UINT32,
+	Rational,
+	Other,
+	INT16,
+	SubExif,
+	INT32,
+	SRational,
+	Double,
+	UINT64,
+	INT64
+};
+
+declare class GPSInfo
+{
+	lat: number;
+	lon: number;
+	altitude: number;
+	gpsTime: data.Timestamp;
+}
+
+export function loadImageFromBlob(blob: Blob): Promise<Image>;
+
+export class EXIFItem
+{
+	id: number;
+	type: EXIFType;
+	data: any;
+
+	constructor(id: number, type: EXIFType, data: any);
+	clone(): EXIFItem;
+};
+
+export class EXIFData
+{
+	exifMaker: EXIFMaker;
+	exifMap: object;
+
+	constructor(exifMaker: EXIFMaker);
+
+	getEXIFMaker(): EXIFMaker;
+	clone(): EXIFData;
+	addBytes(id: number, data: number[]): void;
+	addString(id: number, data: string): void;
+	addUInt16(id: number, data: number[]): void;
+	addUInt32(id: number, data: number[]): void;
+	addInt16(id: number, data: number[]): void;
+	addInt32(id: number, data: number[]): void;
+	addRational(id: number, data: number[]): void; //UInt32[]
+	addSRational(id: number, data: number[]): void; //Int32[]
+	addOther(id: number, data: ArrayBuffer): void;
+	addSubEXIF(id: number, data: EXIFData): void;
+	addDouble(id: number, data: number[]): void;
+	addUInt64(id: number, data: number[]): void;
+	addInt64(id: number, data: number[]): void;
+	remove(id: number): void;
+
+	getExifIds(): number[];
+	getExifType(id: number): EXIFType;
+	getExifItem(id: number): EXIFItem | null;
+	getExifUInt16(id: number): number[] | null;
+	getExifUInt32(id: number): number[] | null;
+	getExifSubexif(id: number): EXIFData | null;
+	getExifOther(id: number): ArrayBuffer | null;
+
+	getPhotoDate(): data.Timestamp;
+	getPhotoMake(): string;
+	getPhotoModel(): string;
+	getPhotoLens(): string;
+	getPhotoFNumber(): number;
+	getPhotoExpTime(): number;
+	getPhotoISO(): number;
+	getPhotoFocalLength(): number;
+	getPhotoLocation(): GPSInfo | null;
+
+	getProperties(): object;
+	parseMakerNote(buff: ArrayBuffer): EXIFData | null;
+
+	static getEXIFName(exifMaker: EXIFMaker, id: number, subId: number): string;
+	static parseIFD(reader: data.ByteReader, ofst: number, lsb: boolean, nextOfst: object, readBase: number, maker?: EXIFMaker);
+};
+
+export class StaticImage
+{
+	img: HTMLImageElement;
+	exif: any;
+	
+	constructor(img: HTMLImageElement);
+	setExif(exif: any): void;
+	getWidth(): number;
+	getHeight(): number;
+	getProperties(): object;
+
+	createCanvas(): HTMLCanvasElement;
+	exportJPG(quality?: number): Promise<Blob | null>;
+	exportWEBP(quality?: number): Promise<Blob | null>;
+	exportPNG(): Promise<Blob | null>;
+}