@motionscript/geography 0.1.0-alpha.8 → 0.1.0

package/src/border/selection.ts

@@ -1,95 +1,95 @@
-import type { GeoFeature } from "./format"
-import { countryFileKey, geoFileEntry, statesFileKey } from "./loader"
-import { geoRegistry } from "./registry"
-
-export type GeoLevel = "country" | "state"
-export type GeoFrame = "mainland" | "all"
-
-const CODE = /^[A-Z]{2}(-[A-Z0-9]{1,3})?$/
-
-/** `"fr, de"`, `["FR", "de"]` → `["FR", "DE"]`; unique, in order, empties dropped. */
-export function normalizeIso(value: unknown): string[] {
-    const raw = Array.isArray(value) ? value : typeof value === "string" ? value.split(/[\s,;]+/) : []
-    const out: string[] = []
-    for (const item of raw) {
-        if (typeof item !== "string") continue
-        const code = item.trim().toUpperCase()
-        if (code && !out.includes(code)) out.push(code)
-    }
-    return out
-}
-
-function isSubdivision(code: string): boolean {
-    return code.includes("-")
-}
-
-/** Every data file a selection reads, for `declareAssets`. Depends on nothing but its arguments. */
-export function geoFilesFor(codes: readonly string[], level: GeoLevel): string[] {
-    const files = new Set<string>()
-    for (const code of codes) {
-        if (!CODE.test(code) || geoRegistry.defined(code)) continue
-        if (isSubdivision(code)) files.add(statesFileKey(code.slice(0, 2)))
-        else files.add(level === "state" ? statesFileKey(code) : countryFileKey(code))
-    }
-    return [...files]
-}
-
-export interface GeoSelection {
-    features: GeoFeature[]
-    /** A file this selection needs has not landed yet. */
-    pending: boolean
-    /** Codes whose file loaded without them. */
-    unknown: string[]
-}
-
-/**
- * The features a selection draws. A bare country code at state level is its
- * first-level subdivisions — minus the remote ones when framing the mainland —
- * or the country itself when it has none.
- */
-export function selectGeoFeatures(codes: readonly string[], level: GeoLevel, frame: GeoFrame): GeoSelection {
-    const features: GeoFeature[] = []
-    const seen = new Set<string>()
-    const unknown: string[] = []
-    let pending = false
-
-    const add = (feature: GeoFeature) => {
-        if (seen.has(feature.code)) return
-        seen.add(feature.code)
-        features.push(feature)
-    }
-
-    for (const code of codes) {
-        const defined = geoRegistry.defined(code)
-        if (defined) {
-            add(defined)
-            continue
-        }
-        if (!CODE.test(code)) {
-            unknown.push(code)
-            continue
-        }
-        const subdivision = isSubdivision(code)
-        const key = subdivision || level === "state" ? statesFileKey(code.slice(0, 2)) : countryFileKey(code)
-        const entry = geoFileEntry(key)
-        if (!entry || entry.status !== "ready") {
-            if (!entry) pending = true
-            continue
-        }
-        const file = entry.file.features
-        if (subdivision || level === "country") {
-            const feature = file.get(code)
-            if (feature) add(feature)
-            else unknown.push(code)
-            continue
-        }
-        const children = [...file.values()].filter(
-            (f) => f.parent === code && f.first && !(frame === "mainland" && f.remote)
-        )
-        if (children.length > 0) children.forEach(add)
-        else if (file.get(code)) add(file.get(code)!)
-        else unknown.push(code)
-    }
-
-    return { features, pending, unknown }
-}
+import type { GeoFeature } from "./format"
+import { countryFileKey, geoFileEntry, statesFileKey } from "./loader"
+import { geoRegistry } from "./registry"
+
+export type GeoLevel = "country" | "state"
+export type GeoFrame = "mainland" | "all"
+
+const CODE = /^[A-Z]{2}(-[A-Z0-9]{1,3})?$/
+
+/** `"fr, de"`, `["FR", "de"]` → `["FR", "DE"]`; unique, in order, empties dropped. */
+export function normalizeIso(value: unknown): string[] {
+    const raw = Array.isArray(value) ? value : typeof value === "string" ? value.split(/[\s,;]+/) : []
+    const out: string[] = []
+    for (const item of raw) {
+        if (typeof item !== "string") continue
+        const code = item.trim().toUpperCase()
+        if (code && !out.includes(code)) out.push(code)
+    }
+    return out
+}
+
+function isSubdivision(code: string): boolean {
+    return code.includes("-")
+}
+
+/** Every data file a selection reads, for `declareAssets`. Depends on nothing but its arguments. */
+export function geoFilesFor(codes: readonly string[], level: GeoLevel): string[] {
+    const files = new Set<string>()
+    for (const code of codes) {
+        if (!CODE.test(code) || geoRegistry.defined(code)) continue
+        if (isSubdivision(code)) files.add(statesFileKey(code.slice(0, 2)))
+        else files.add(level === "state" ? statesFileKey(code) : countryFileKey(code))
+    }
+    return [...files]
+}
+
+export interface GeoSelection {
+    features: GeoFeature[]
+    /** A file this selection needs has not landed yet. */
+    pending: boolean
+    /** Codes whose file loaded without them. */
+    unknown: string[]
+}
+
+/**
+ * The features a selection draws. A bare country code at state level is its
+ * first-level subdivisions — minus the remote ones when framing the mainland —
+ * or the country itself when it has none.
+ */
+export function selectGeoFeatures(codes: readonly string[], level: GeoLevel, frame: GeoFrame): GeoSelection {
+    const features: GeoFeature[] = []
+    const seen = new Set<string>()
+    const unknown: string[] = []
+    let pending = false
+
+    const add = (feature: GeoFeature) => {
+        if (seen.has(feature.code)) return
+        seen.add(feature.code)
+        features.push(feature)
+    }
+
+    for (const code of codes) {
+        const defined = geoRegistry.defined(code)
+        if (defined) {
+            add(defined)
+            continue
+        }
+        if (!CODE.test(code)) {
+            unknown.push(code)
+            continue
+        }
+        const subdivision = isSubdivision(code)
+        const key = subdivision || level === "state" ? statesFileKey(code.slice(0, 2)) : countryFileKey(code)
+        const entry = geoFileEntry(key)
+        if (!entry || entry.status !== "ready") {
+            if (!entry) pending = true
+            continue
+        }
+        const file = entry.file.features
+        if (subdivision || level === "country") {
+            const feature = file.get(code)
+            if (feature) add(feature)
+            else unknown.push(code)
+            continue
+        }
+        const children = [...file.values()].filter(
+            (f) => f.parent === code && f.first && !(frame === "mainland" && f.remote)
+        )
+        if (children.length > 0) children.forEach(add)
+        else if (file.get(code)) add(file.get(code)!)
+        else unknown.push(code)
+    }
+
+    return { features, pending, unknown }
+}

package/src/border/simplify.ts

@@ -1,110 +1,110 @@
-/**
- * Visvalingam–Whyatt weights for a hand-defined ring, in the same buckets the
- * generated data carries (`-2·log2` of the effective area in steradians), so a
- * shape passed to `geoRegistry.define` answers to `detail` like any other.
- *
- * Planar in degrees with longitude scaled by latitude: accurate enough for the
- * handful of shapes an author defines, where the generated data uses the exact
- * spherical area.
- */
-export function ringBuckets(points: Float64Array): Uint8Array {
-    const n = points.length / 2
-    const buckets = new Uint8Array(n)
-    if (n < 3) return buckets
-
-    const radians = Math.PI / 180
-    const weight = new Float64Array(n)
-    const prev = new Int32Array(n)
-    const next = new Int32Array(n)
-    for (let i = 0; i < n; i++) {
-        prev[i] = i - 1
-        next[i] = i + 1
-    }
-
-    const area = (a: number, b: number, c: number): number => {
-        const cos = Math.cos(points[b * 2 + 1] * radians)
-        const ax = points[a * 2] * cos, ay = points[a * 2 + 1]
-        const bx = points[b * 2] * cos, by = points[b * 2 + 1]
-        const cx = points[c * 2] * cos, cy = points[c * 2 + 1]
-        return (Math.abs((bx - ax) * (cy - ay) - (cx - ax) * (by - ay)) / 2) * radians * radians
-    }
-
-    const heap: number[] = []
-    const position = new Int32Array(n).fill(-1)
-    const less = (i: number, j: number) => weight[heap[i]] < weight[heap[j]]
-    const swap = (i: number, j: number) => {
-        ;[heap[i], heap[j]] = [heap[j], heap[i]]
-        position[heap[i]] = i
-        position[heap[j]] = j
-    }
-    const up = (i: number) => {
-        while (i > 0) {
-            const parent = (i - 1) >> 1
-            if (!less(i, parent)) break
-            swap(i, parent)
-            i = parent
-        }
-    }
-    const down = (i: number) => {
-        for (;;) {
-            const l = 2 * i + 1
-            const r = l + 1
-            let smallest = i
-            if (l < heap.length && less(l, smallest)) smallest = l
-            if (r < heap.length && less(r, smallest)) smallest = r
-            if (smallest === i) return
-            swap(i, smallest)
-            i = smallest
-        }
-    }
-    const push = (i: number) => {
-        position[i] = heap.length
-        heap.push(i)
-        up(heap.length - 1)
-    }
-    const remove = (i: number) => {
-        const at = position[i]
-        const last = heap.pop()!
-        position[i] = -1
-        if (at < heap.length) {
-            heap[at] = last
-            position[last] = at
-            up(at)
-            down(position[last])
-        }
-    }
-
-    for (let i = 1; i < n - 1; i++) {
-        weight[i] = area(i - 1, i, i + 1)
-        push(i)
-    }
-
-    let floor = 0
-    const final = new Float64Array(n)
-    final[0] = final[n - 1] = Infinity
-    while (heap.length > 0) {
-        const i = heap[0]
-        remove(i)
-        floor = Math.max(floor, weight[i])
-        final[i] = floor
-        const p = prev[i]
-        const q = next[i]
-        if (p >= 0) next[p] = q
-        if (q < n) prev[q] = p
-        for (const j of [p, q]) {
-            if (j <= 0 || j >= n - 1 || position[j] < 0) continue
-            remove(j)
-            weight[j] = area(prev[j], j, next[j])
-            push(j)
-        }
-    }
-
-    for (let i = 0; i < n; i++) buckets[i] = weightBucket(final[i])
-    return buckets
-}
-
-export function weightBucket(weight: number): number {
-    if (weight === Infinity) return 0
-    if (!(weight > 0)) return 255
-    return Math.min(254, Math.max(1, Math.round(-2 * Math.log2(weight))))
-}
+/**
+ * Visvalingam–Whyatt weights for a hand-defined ring, in the same buckets the
+ * generated data carries (`-2·log2` of the effective area in steradians), so a
+ * shape passed to `geoRegistry.define` answers to `detail` like any other.
+ *
+ * Planar in degrees with longitude scaled by latitude: accurate enough for the
+ * handful of shapes an author defines, where the generated data uses the exact
+ * spherical area.
+ */
+export function ringBuckets(points: Float64Array): Uint8Array {
+    const n = points.length / 2
+    const buckets = new Uint8Array(n)
+    if (n < 3) return buckets
+
+    const radians = Math.PI / 180
+    const weight = new Float64Array(n)
+    const prev = new Int32Array(n)
+    const next = new Int32Array(n)
+    for (let i = 0; i < n; i++) {
+        prev[i] = i - 1
+        next[i] = i + 1
+    }
+
+    const area = (a: number, b: number, c: number): number => {
+        const cos = Math.cos(points[b * 2 + 1] * radians)
+        const ax = points[a * 2] * cos, ay = points[a * 2 + 1]
+        const bx = points[b * 2] * cos, by = points[b * 2 + 1]
+        const cx = points[c * 2] * cos, cy = points[c * 2 + 1]
+        return (Math.abs((bx - ax) * (cy - ay) - (cx - ax) * (by - ay)) / 2) * radians * radians
+    }
+
+    const heap: number[] = []
+    const position = new Int32Array(n).fill(-1)
+    const less = (i: number, j: number) => weight[heap[i]] < weight[heap[j]]
+    const swap = (i: number, j: number) => {
+        ;[heap[i], heap[j]] = [heap[j], heap[i]]
+        position[heap[i]] = i
+        position[heap[j]] = j
+    }
+    const up = (i: number) => {
+        while (i > 0) {
+            const parent = (i - 1) >> 1
+            if (!less(i, parent)) break
+            swap(i, parent)
+            i = parent
+        }
+    }
+    const down = (i: number) => {
+        for (;;) {
+            const l = 2 * i + 1
+            const r = l + 1
+            let smallest = i
+            if (l < heap.length && less(l, smallest)) smallest = l
+            if (r < heap.length && less(r, smallest)) smallest = r
+            if (smallest === i) return
+            swap(i, smallest)
+            i = smallest
+        }
+    }
+    const push = (i: number) => {
+        position[i] = heap.length
+        heap.push(i)
+        up(heap.length - 1)
+    }
+    const remove = (i: number) => {
+        const at = position[i]
+        const last = heap.pop()!
+        position[i] = -1
+        if (at < heap.length) {
+            heap[at] = last
+            position[last] = at
+            up(at)
+            down(position[last])
+        }
+    }
+
+    for (let i = 1; i < n - 1; i++) {
+        weight[i] = area(i - 1, i, i + 1)
+        push(i)
+    }
+
+    let floor = 0
+    const final = new Float64Array(n)
+    final[0] = final[n - 1] = Infinity
+    while (heap.length > 0) {
+        const i = heap[0]
+        remove(i)
+        floor = Math.max(floor, weight[i])
+        final[i] = floor
+        const p = prev[i]
+        const q = next[i]
+        if (p >= 0) next[p] = q
+        if (q < n) prev[q] = p
+        for (const j of [p, q]) {
+            if (j <= 0 || j >= n - 1 || position[j] < 0) continue
+            remove(j)
+            weight[j] = area(prev[j], j, next[j])
+            push(j)
+        }
+    }
+
+    for (let i = 0; i < n; i++) buckets[i] = weightBucket(final[i])
+    return buckets
+}
+
+export function weightBucket(weight: number): number {
+    if (weight === Infinity) return 0
+    if (!(weight > 0)) return 255
+    return Math.min(254, Math.max(1, Math.round(-2 * Math.log2(weight))))
+}

package/src/index.ts

@@ -1,2 +1,2 @@
-export * from "./border";
-export { NODES } from "./nodes";
+export * from "./border";
+export { NODES } from "./nodes";

package/src/nodes.ts

@@ -1,16 +1,16 @@
-import { GeoBorder } from "./border";
-
-/**
- * Every node type this package publishes.
- *
- * A host registers these by handing the array to an engine —
- * `new Engine(platform, { nodes: NODES })` — which reads each component's key.
- * Defining a component only *declares* that key: nothing is registered by
- * importing a module, so a registry holds exactly what its owner asked for.
- *
- * Listing the component **values** is also what survives bundling: this package
- * declares `sideEffects: false`, and a document names a node type by string, so
- * an import kept only for its side effect is exactly what gets shaken out.
- */
-// Typed by name, so the declaration names each component rather than spelling out its type through core.
-export const NODES: (typeof GeoBorder)[] = [GeoBorder];
+import { GeoBorder } from "./border";
+
+/**
+ * Every node type this package publishes.
+ *
+ * A host registers these by handing the array to an engine —
+ * `new Engine(platform, { nodes: NODES })` — which reads each component's key.
+ * Defining a component only *declares* that key: nothing is registered by
+ * importing a module, so a registry holds exactly what its owner asked for.
+ *
+ * Listing the component **values** is also what survives bundling: this package
+ * declares `sideEffects: false`, and a document names a node type by string, so
+ * an import kept only for its side effect is exactly what gets shaken out.
+ */
+// Typed by name, so the declaration names each component rather than spelling out its type through core.
+export const NODES: (typeof GeoBorder)[] = [GeoBorder];