@mwater/visualization 5.4.0 → 5.4.2

package/src/widgets/text/TextWidgetComponent.tsx

@@ -13,6 +13,7 @@ import ActionCancelModalComponent from "@mwater/react-library/lib/ActionCancelMo
 import { FormGroup } from "@mwater/react-library/lib/bootstrap"
 import ColorComponent from "../../ColorComponent"
 import { Select } from "@mwater/react-library/lib/bootstrap"
+import { translateHtmlItems } from "../../richtext/ExprItemsTranslator"
 
 export interface TextWidgetComponentProps {
   design: TextWidgetDesign
@@ -28,8 +29,15 @@ export interface TextWidgetComponentProps {
   /** Table that is filtered to have one row */
   singleRowTable?: string
   namedStrings?: any
+
   /** A key that changes when the widget should be refreshed */
   refreshKey?: any
+
+  /** Locale to use for display */
+  locale: string
+
+  /** Translate function to use for display. Returns same string when editing. */
+  translate: (input: string) => string
 }
 
 // Widget which displays styled text with embedded expressions
@@ -200,9 +208,15 @@ export default class TextWidgetComponent extends AsyncLoadComponent<TextWidgetCo
 
     const padding = this.props.design.padding ?? 0
 
+    // Translate items if needed
+    const translatedDesign = this.props.onDesignChange ? this.props.design : {
+      ...this.props.design,
+      items: translateHtmlItems(this.props.design.items || [], this.props.translate)
+    }
+
     return (
       <TextComponent
-        design={this.props.design}
+        design={translatedDesign}
         onDesignChange={this.props.onDesignChange}
         schema={this.props.schema}
         dataSource={this.props.dataSource}
@@ -211,6 +225,7 @@ export default class TextWidgetComponent extends AsyncLoadComponent<TextWidgetCo
         height={this.props.height ? this.props.height - padding * 2 : undefined}
         singleRowTable={this.props.singleRowTable}
         namedStrings={this.props.namedStrings}
+        locale={this.props.locale}
       />
     )
   }

package/src/widgets/text/TextWidgetDesign.ts

@@ -1,11 +1,8 @@
-import { HtmlItemExpr } from "../../richtext/ExprItemsHtmlConverter"
-import { HtmlItem } from "../../richtext/ItemsHtmlConverter"
-
-export type TextWidgetItem = HtmlItem | HtmlItemExpr
+import { HtmlItemOrExpr } from "../../richtext/ExprItemsHtmlConverter"
 
 export interface TextWidgetDesign {
   /** Text widget stores its content as array of items. See ItemsHtmlConverter TODO */
-  items: TextWidgetItem[]
+  items?: HtmlItemOrExpr[]
 
   /** "title" for title block. default is "default" */
   style?: "title" | "default" | "header" | "footer"
@@ -29,5 +26,5 @@ export interface TextWidgetDesign {
 
 /** Returns true if the text widget design is empty. */
 export function isEmptyTextWidgetDesign(design: TextWidgetDesign | undefined): boolean {
-  return design == null || design.items.length === 0
-}
+  return design == null || (design.items != null && design.items.length === 0)
+}

package/test/IdSelectionTests.ts

@@ -0,0 +1,54 @@
+import { assert } from "chai"
+import IdSelection from "../src/IdSelection"
+
+describe("IdSelection", function () {
+  beforeEach(function(this: any) {
+    this.sel = new IdSelection()
+  })
+
+  it("adds id", function(this: any) {
+    const sel = this.sel.add("1")
+    assert.isTrue(sel.isSelected("1"))
+    assert.isFalse(sel.isSelected("2"))
+  })
+
+  it("removes id", function(this: any) {
+    let sel = this.sel.add("1")
+    sel = sel.remove("1")
+    assert.isFalse(sel.isSelected("1"))
+    assert.isFalse(sel.isSelected("2"))
+  })
+
+  it("toggles id", function(this: any) {
+    let sel = this.sel.toggle("1")
+    assert.isTrue(sel.isSelected("1"))
+    sel = sel.toggle("1")
+    assert.isFalse(sel.isSelected("1"))
+  })
+
+  it("inverts", function(this: any) {
+    let sel = this.sel.add("1")
+    sel = sel.invert()
+    assert.isTrue(sel.isSelected("2"))
+    assert.isFalse(sel.isSelected("1"))
+  })
+
+  it("adds in inverts", function(this: any) {
+    let sel = this.sel.add("1")
+    sel = sel.invert()
+    sel = sel.add("1")
+    assert.isTrue(sel.isSelected("1"))
+  })
+
+  it("none", function(this: any) {
+    let sel = this.sel.add("1")
+    sel = sel.none()
+    assert.isFalse(sel.isSelected("1"))
+  })
+
+  return it("all", function(this: any) {
+    const sel = this.sel.all("1")
+    assert.isTrue(sel.isSelected("1"))
+    assert.isTrue(sel.isSelected("2"))
+  })
+})

package/test/LayeredChartCompilerTests.ts

@@ -1,5 +1,3 @@
-// TODO: This file was created by bulk-decaffeinate.
-// Sanity-check the conversion and remove this comment.
 import _ from "lodash"
 import { assert } from "chai"
 import * as fixtures from "./fixtures"

package/test/richtext/ExprItemsTranslatorTests.ts

@@ -0,0 +1,144 @@
+import { assert } from "chai"
+import { translateHtmlItems, getHtmlItemsStrings } from "../../src/richtext/ExprItemsTranslator"
+import { HtmlItemElement } from "../../src/richtext/ItemsHtmlConverter"
+import { HtmlItemExpr, HtmlItemOrExpr } from "../../src/richtext/ExprItemsHtmlConverter"
+
+describe("ExprItemsTranslator", function () {
+  describe("translateHtmlItems", function () {
+    it("should translate simple strings", function () {
+      const items: HtmlItemOrExpr[] = ["Hello ", "World"]
+      const translatedItems = translateHtmlItems(items, (input) => input.toUpperCase())
+      assert.deepEqual(translatedItems, ["HELLO WORLD"])
+    })
+
+    it("should translate nested items", function () {
+      const items: HtmlItemOrExpr[] = [
+        {
+          type: "element",
+          tag: "p",
+          items: ["Hello", { type: "element", tag: "b", items: ["World"] } as HtmlItemElement]
+        } as HtmlItemElement
+      ]
+      const translatedItems = translateHtmlItems(items, (input) => input.toUpperCase())
+      assert.deepEqual(translatedItems, [
+        {
+          type: "element",
+          tag: "p",
+          items: ["HELLO", { type: "element", tag: "b", items: ["WORLD"] } as HtmlItemElement]
+        } as HtmlItemElement
+      ])
+    })
+
+    it("should translate expression items", function () {
+      const items: HtmlItemOrExpr[] = [
+        {
+          type: "expr",
+          id: "1",
+          expr: { type: "literal", valueType: "text", value: "Hello" },
+          labelText: "Greeting"
+        } as HtmlItemExpr
+      ]
+      const translatedItems = translateHtmlItems(items, (input) => input.toUpperCase())
+      assert.deepEqual(translatedItems, [
+        {
+          type: "expr",
+          id: "1",
+          expr: { type: "literal", valueType: "text", value: "Hello" },
+          labelText: "GREETING"
+        } as HtmlItemExpr
+      ])
+    })
+
+    it("should translate expression items within a string", function () {
+      const items: HtmlItemOrExpr[] = [
+        "Hello, ",
+        {
+          type: "expr",
+          id: "1",
+          expr: { type: "literal", valueType: "text", value: "Hello" },
+          labelText: "Greeting"
+        } as HtmlItemExpr,
+        "!"
+      ]
+      const translatedItems = translateHtmlItems(items, (input) => input.toUpperCase())
+      assert.deepEqual(translatedItems, [
+        "HELLO, ",
+        {
+          type: "expr",
+          id: "1",
+          expr: { type: "literal", valueType: "text", value: "Hello" },
+          labelText: "GREETING"
+        } as HtmlItemExpr,
+        "!"
+      ])
+    })
+
+    it("should translate links while preserving the href", function () {
+      const items: HtmlItemOrExpr[] = [
+        "Hello, ",
+        {
+          type: "element",
+          tag: "a",
+          items: ["there"],
+          href: "https://example.com"
+        } as HtmlItemElement,
+        "!"
+      ]
+      const translatedItems = translateHtmlItems(items, (input) => input.toUpperCase())
+      assert.deepEqual(translatedItems, [
+        "HELLO, ",
+        {
+          type: "element",
+          tag: "a",
+          items: ["THERE"],
+          href: "HTTPS://EXAMPLE.COM"
+        } as HtmlItemElement,
+        "!"
+      ])
+    })
+
+    it("should collect all unique strings", function () {
+      const items: HtmlItemOrExpr[] = [
+        "Start ",
+        {
+          type: "element",
+          tag: "p",
+          items: ["Hello ", { type: "element", tag: "b", items: ["World"] }]
+        } as HtmlItemElement,
+        " This is a ",
+        {
+          type: "expr",
+          id: "1",
+          expr: { type: "literal", valueType: "text", value: "Hello" },
+          labelText: "Greeting"
+        } as HtmlItemExpr,
+        "!"
+      ]
+      const strings = getHtmlItemsStrings(items)
+      assert.deepEqual(strings, ["Start", "Hello <b>World</b>", "Greeting", "This is a {0}!"])
+    })
+  })
+
+  describe("getHtmlItemsStrings", function () {
+    it("should collect all unique strings", function () {
+      const items: HtmlItemOrExpr[] = [
+        "Start ",
+        {
+          type: "element",
+          tag: "p",
+          items: ["Hello ", { type: "element", tag: "b", items: ["World"] }]
+        } as HtmlItemElement,
+        " This is a ",
+        {
+          type: "expr",
+          id: "1",
+          expr: { type: "literal", valueType: "text", value: "Hello" },
+          labelText: "Greeting"
+        } as HtmlItemExpr,
+        "!"
+      ]
+      const strings = getHtmlItemsStrings(items)
+      assert.deepEqual(strings, ["Start", "Hello <b>World</b>", "Greeting", "This is a {0}!"])
+    })
+  })
+})

package/test/wellknownTests.ts

@@ -0,0 +1,144 @@
+import { assert } from "chai"
+import { parse, stringify } from "../src/wellknown"
+
+describe("WellKnown", () => {
+  describe("parse", () => {
+    it("parses a point", () => {
+      const result = parse("POINT (1 2)")
+      assert.deepEqual(result, {
+        type: "Point",
+        coordinates: [1, 2]
+      })
+    })
+
+    it("parses a linestring", () => {
+      const result = parse("LINESTRING (1 2, 3 4)")
+      assert.deepEqual(result, {
+        type: "LineString",
+        coordinates: [[1, 2], [3, 4]]
+      })
+    })
+
+    it("parses a polygon", () => {
+      const result = parse("POLYGON ((1 2, 3 4, 5 6, 1 2))")
+      assert.deepEqual(result, {
+        type: "Polygon",
+        coordinates: [[[1, 2], [3, 4], [5, 6], [1, 2]]]
+      })
+    })
+
+    it("parses a polygon with hole", () => {
+      const result = parse("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (2 2, 8 2, 8 8, 2 8, 2 2))")
+      assert.deepEqual(result, {
+        type: "Polygon",
+        coordinates: [
+          [[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]],
+          [[2, 2], [8, 2], [8, 8], [2, 8], [2, 2]]
+        ]
+      })
+    })
+
+    it("parses a multipoint", () => {
+      const result = parse("MULTIPOINT ((1 2), (3 4))")
+      assert.deepEqual(result, {
+        type: "MultiPoint",
+        coordinates: [[1, 2], [3, 4]]
+      })
+    })
+
+    it("handles SRID", () => {
+      const result = parse("SRID=4326;POINT (1 2)")
+      assert.deepEqual(result, {
+        type: "Point",
+        coordinates: [1, 2],
+        crs: {
+          type: "name",
+          properties: {
+            name: "urn:ogc:def:crs:EPSG::4326"
+          }
+        }
+      })
+    })
+
+    it("returns null for invalid input", () => {
+      const result = parse("POINT (not a point)")
+      assert.isNull(result)
+    })
+
+    it("parses a multilinestring", () => {
+      const result = parse("MULTILINESTRING ((1 2, 3 4), (5 6, 7 8))")
+      assert.deepEqual(result, {
+        type: "MultiLineString",
+        coordinates: [
+          [[1, 2], [3, 4]],
+          [[5, 6], [7, 8]]
+        ]
+      })
+    })
+
+    it("parses a multilinestring with z coordinate", () => {
+      const result = parse("MULTILINESTRING Z ((1 2 10, 3 4 11), (5 6 12, 7 8 13))")
+      assert.deepEqual(result, {
+        type: "MultiLineString",
+        coordinates: [
+          [[1, 2, 10], [3, 4, 11]],
+          [[5, 6, 12], [7, 8, 13]]
+        ]
+      })
+    })
+
+    it("parses a multilinestring with zm coordinate, ignoring m", () => {
+      const result = parse("MULTILINESTRING ZM ((1 2 10 100, 3 4 11 101), (5 6 12 102, 7 8 13 103))")
+      assert.deepEqual(result, {
+        type: "MultiLineString",
+        coordinates: [
+          [[1, 2, 10], [3, 4, 11]],
+          [[5, 6, 12], [7, 8, 13]]
+        ]
+      })
+    })
+  })
+
+  describe("stringify", () => {
+    it("stringifies a point", () => {
+      const point = {
+        type: "Point",
+        coordinates: [1, 2]
+      }
+      assert.equal(stringify(point), "POINT (1 2)")
+    })
+
+    it("stringifies a linestring", () => {
+      const linestring = {
+        type: "LineString",
+        coordinates: [[1, 2], [3, 4]]
+      }
+      assert.equal(stringify(linestring), "LINESTRING (1 2, 3 4)")
+    })
+
+    it("stringifies a polygon", () => {
+      const polygon = {
+        type: "Polygon",
+        coordinates: [[[1, 2], [3, 4], [5, 6], [1, 2]]]
+      }
+      assert.equal(stringify(polygon), "POLYGON ((1 2, 3 4, 5 6, 1 2))")
+    })
+
+    it("stringifies a multilinestring", () => {
+      const multilinestring = {
+        type: "MultiLineString",
+        coordinates: [
+          [[1, 2], [3, 4]],
+          [[5, 6], [7, 8]]
+        ]
+      }
+      assert.equal(stringify(multilinestring), "MULTILINESTRING ((1 2, 3 4), (5 6, 7 8))")
+    })
+
+    it("throws error for invalid input", () => {
+      assert.throws(() => {
+        stringify({ type: "Invalid" })
+      }, "stringify requires a valid GeoJSON Feature or geometry object as input")
+    })
+  })
+})