umap-project 2.6.2__py3-none-any.whl → 2.7.0__py3-none-any.whl

umap/static/umap/map.css

@@ -500,7 +500,9 @@ ul.photon-autocomplete {
 }
 .leaflet-container .leaflet-control-edit-save,
 .leaflet-container .leaflet-control-edit-cancel,
-.leaflet-container .leaflet-control-edit-disable {
+.leaflet-container .leaflet-control-edit-disable,
+.leaflet-container .leaflet-control-connected-peers
+{
     display: block;
     border: none;
     font-size: 12px;
@@ -510,9 +512,17 @@ ul.photon-autocomplete {
     line-height: 30px;
     padding: 0 20px;
 }
+.leaflet-container .leaflet-control-connected-peers,
+.dark [type="button"].leaflet-control-connected-peers:hover
+{
+    background-color: var(--color-lightCyan);
+    color: var(--color-dark);
+}
+
 .leaflet-container .leaflet-control-edit-disable:before,
 .leaflet-container .leaflet-control-edit-save:before,
-.leaflet-container .leaflet-control-edit-cancel:before {
+.leaflet-container .leaflet-control-edit-cancel:before,
+.leaflet-container .leaflet-control-connected-peers:before {
     display: inline-block;
     width: 19px;
     height: 24px;
@@ -523,9 +533,15 @@ ul.photon-autocomplete {
     content: ' ';
     text-align: center;
 }
+
+.leaflet-container .leaflet-control-connected-peers:before {
+    background-image: url('./img/16.svg');
+}
+
 .leaflet-container .leaflet-control-edit-disable span,
 .leaflet-container .leaflet-control-edit-save span,
-.leaflet-container .leaflet-control-edit-cancel span {
+.leaflet-container .leaflet-control-edit-cancel span,
+.leaflet-container .leaflet-control-connected-peers span{
     margin-inline-start: 10px;
 }
 .leaflet-container .leaflet-control-edit-save:before {
@@ -534,8 +550,12 @@ ul.photon-autocomplete {
 .leaflet-container .leaflet-control-edit-disable:before {
     background-position: -50px -25px;
 }
+.leaflet-container .leaflet-control-connected-peers:before {
+    background-position: -2px -95px;
+}
 .leaflet-container .leaflet-control-edit-cancel,
-.leaflet-container .leaflet-control-edit-disable {
+.leaflet-container .leaflet-control-edit-disable,
+.leaflet-container .leaflet-control-connected-peers{
     border: 0.5px solid rgba(153, 153, 153, 0.40);
 }
 .leaflet-container .leaflet-control-edit-cancel:hover,
@@ -592,17 +612,16 @@ ul.photon-autocomplete {
     left: 0;
     right: 0;
     height: 46px;
-    background-color: var(--color-darkGray);
     padding: 0 10px;
     text-align: start;
     line-height: var(--control-size);
     cursor: auto;
     border-bottom: 1px solid #222;
     z-index: var(--zindex-panels);
-    opacity: 0.98;
-    color: #fff;
     display: flex;
     justify-content: space-between;
+    background-color: var(--background-color);
+    color: var(--text-color);
 }
 .umap-left-edit-toolbox,
 .umap-right-edit-toolbox {
@@ -820,7 +839,6 @@ a.umap-control-caption,
 .umap-browser .off .feature {
     display: none;
 }
-.umap-facet-search .formbox,
 .umap-browser .datalayer {
     margin-bottom: 2px;
     border-radius: 2px;
@@ -831,7 +849,7 @@ a.umap-control-caption,
 .umap-browser.dark .datalayer ul {
     border: 1px solid #232729;
 }
-.umap-browser h5, .umap-facet-search h5 {
+.umap-browser h5 {
     margin-bottom: 0;
     overflow: hidden;
     padding-inline-start: 5px;
@@ -849,7 +867,7 @@ a.umap-control-caption,
 .umap-browser h5 span {
     margin-inline-start: 10px;
 }
-.umap-browser li, .umap-facet-search li {
+.umap-browser li {
     padding: 2px 0;
     white-space: nowrap;
     overflow: hidden;
@@ -867,13 +885,15 @@ a.umap-control-caption,
     -moz-box-sizing:border-box;
     -webkit-box-sizing:border-box;
     box-sizing: border-box;
-    background: none;
     display: inline-block;
     padding: 0;
     width: 24px;
     text-align: center;
     margin-inline-start: 5px;
 }
+.umap-browser .marker .feature-color {
+    background: none;
+}
 .umap-browser.dark .datalayer .feature-color {
     box-shadow: 0 0 2px 0 #999 inset;
 }
@@ -884,18 +904,6 @@ a.umap-control-caption,
     font-style: normal;
     font-weight: bold;
 }
-.umap-browser .polygon .feature-color,
-.umap-browser .polyline .feature-color {
-    box-shadow: 0 0 2px 0 black inset;
-    background-image: url('./img/24.svg');
-    background-size: 500%;
-}
-.umap-browser .polyline .feature-color {
-    background-position: -72px -23px;
-}
-.umap-browser .polygon .feature-color {
-    background-position: -48px -25px;
-}
 .umap-browser .datalayer-toggle-list {
     float: inline-end;
     margin-inline-end: 5px;
@@ -925,6 +933,16 @@ a.umap-control-caption,
 .umap-caption .umap-map-author {
     padding-inline-start: 31px;
 }
+.umap-browser .main-toolbox {
+    padding-left: 4px; /* Align with toolbox below  */
+    border-top: 1px solid var(--color-mediumGray);
+    margin-top: var(--box-margin);
+    padding-top: 3px;
+    padding-bottom: 3px;
+}
+.umap-browser .main-toolbox i {
+    cursor: pointer;
+}
 
 
 /* ********************************* */
@@ -982,18 +1000,18 @@ a.umap-control-caption,
     vertical-align: middle;
 }
 
-.datalayer-legend {
+.caption-item {
     color: #555;
     padding: 6px 8px;
     box-shadow: 0 0 3px rgba(0,0,0,0.2);
     border-radius: 1px;
 }
-.datalayer-legend ul {
+.caption-item ul {
     list-style-type: none;
     padding: 0;
     margin: 0;
 }
-.datalayer-legend .circles-layer-legend {
+.caption-item .circles-layer-legend {
     padding: var(--box-padding);
 }
 .circles-layer-legend li {
@@ -1499,9 +1517,6 @@ span.popup-icon {
     .umap-main-edit-toolbox .umap-user {
         margin-inline-end: 10px;
     }
-    .umap-main-edit-toolbox .umap-user:after {
-        display: none;
-    }
 }
 @media all and (max-width: 640px) {
     .umap-main-edit-toolbox .umap-user {

umap/static/umap/unittests/hlc.js

@@ -0,0 +1,165 @@
+import { describe, it } from 'mocha'
+import sinon from 'sinon'
+
+import pkg from 'chai'
+const { expect } = pkg
+
+import { HybridLogicalClock } from '../js/modules/sync/hlc.js'
+
+describe('HybridLogicalClock', () => {
+  let clock
+
+  describe('#parse', () => {
+    it('should reject invalid values', () => {
+      clock = new HybridLogicalClock()
+      expect(() => clock.parse('invalid')).to.throw()
+      expect(() => clock.parse('123:456')).to.throw()
+      expect(() => clock.parse('123:456:789:000')).to.throw()
+    })
+
+    it('should parse correct values', () => {
+      clock = new HybridLogicalClock()
+      const result = clock.parse('1625097600000:42:abc-123')
+      expect(result).to.deep.equal({
+        walltime: '1625097600000',
+        nn: 42,
+        id: 'abc-123',
+      })
+    })
+
+    it('should default to 0 for nn if none is provided', () => {
+      clock = new HybridLogicalClock()
+      const result = clock.parse('1625097600000::abc-123')
+      expect(result).to.deep.equal({
+        walltime: '1625097600000',
+        nn: 0,
+        id: 'abc-123',
+      })
+    })
+  })
+
+  describe('#serialize', () => {
+    it('should correctly serialize the clock', () => {
+      clock = new HybridLogicalClock(1625097600000, 42, 'abc-123')
+      expect(clock.serialize()).to.equal('1625097600000:42:abc-123')
+    })
+  })
+
+  describe('#tick', () => {
+    it('should increment walltime when current time is greater', () => {
+      const now = Date.now()
+      clock = new HybridLogicalClock(now - 1000, 0, 'test')
+      const result = clock.tick()
+      const parsed = clock.parse(result)
+      expect(parsed.walltime).to.be.at.least(now.toString())
+      expect(parsed.nn).to.equal(0)
+    })
+
+    it('should increment nn when current time is not greater', () => {
+      const now = Date.now()
+      clock = new HybridLogicalClock(now, 5, 'test')
+      sinon.useFakeTimers(now)
+      const result = clock.tick()
+      const parsed = clock.parse(result)
+      expect(parsed.walltime).to.equal(now.toString())
+      expect(parsed.nn).to.equal(6)
+      sinon.restore()
+    })
+  })
+
+  describe('#receive', () => {
+    it("should use current time when it's greater than both local and remote", () => {
+      const now = Date.now()
+      clock = new HybridLogicalClock(now - 1000, 0, 'local')
+      const result = clock.receive(`${now - 500}:0:remote`)
+      expect(result.walltime).to.be.at.least(now)
+      expect(result.nn).to.equal(0)
+      expect(result.id).to.equal('local')
+    })
+
+    it('should increment nn when local and remote times are equal', () => {
+      const now = Date.now()
+      // mock the clock to be the same time
+      sinon.useFakeTimers(now)
+      clock = new HybridLogicalClock(now, 5, 'local')
+      const result = clock.receive(`${now}:7:remote`)
+      expect(result.walltime).to.be.at.least(now)
+      expect(result.nn).to.equal(8)
+      expect(result.id).to.equal('local')
+    })
+
+    it('should use remote time and increment nn when remote time is greater', () => {
+      const now = Date.now()
+      clock = new HybridLogicalClock(now - 1000, 5, 'local')
+      const result = clock.receive(`${now}:7:remote`)
+      expect(result.walltime).to.be.least(now.toString())
+      expect(result.nn).to.equal(8)
+      expect(result.id).to.equal('local')
+    })
+
+    it('should increment local nn when local time is greater', () => {
+      const now = Date.now()
+      clock = new HybridLogicalClock(now, 5, 'local')
+      const result = clock.receive(`${now - 1000}:7:remote`)
+      expect(result.walltime).to.be.least(now)
+      if (result.walltime > now) {
+        expect(result.nn).to.equal(5)
+      }
+      else {
+        expect(result.nn).to.equal(6)
+      }
+      expect(result.id).to.equal('local')
+    })
+  })
+
+  it('should maintain causal order across multiple operations', () => {
+    const hlc = new HybridLogicalClock()
+
+    // Simulate a sequence of events
+    const event1 = hlc.tick()
+
+    // Simulate some time passing
+    const clock = sinon.useFakeTimers(Date.now() + 100)
+
+    const event2 = hlc.tick()
+
+    // Simulate receiving a message from another node
+    hlc.receive(`${Date.now() - 50}:5:remote-id`)
+
+    const event3 = hlc.tick()
+
+    // Advance time significantly
+    clock.tick(1000)
+
+    const event4 = hlc.tick()
+
+    // Clean up the fake timer
+    clock.restore()
+
+    // Parse all events
+    const parsedEvent1 = hlc.parse(event1)
+    const parsedEvent2 = hlc.parse(event2)
+    const parsedEvent3 = hlc.parse(event3)
+    const parsedEvent4 = hlc.parse(event4)
+
+    // Assertions to ensure causal order is maintained
+    expect(parsedEvent2.walltime).to.be.greaterThan(parsedEvent1.walltime)
+    expect(parsedEvent3.walltime).to.equal(parsedEvent2.walltime)
+    expect(parsedEvent3.nn).to.be.greaterThan(parsedEvent2.nn)
+    expect(parsedEvent4.walltime).to.be.greaterThan(parsedEvent3.walltime)
+
+    // Check that all events have the same id
+    const uniqueIds = new Set([
+      parsedEvent1.id,
+      parsedEvent2.id,
+      parsedEvent3.id,
+      parsedEvent4.id,
+    ])
+    expect(uniqueIds.size).to.equal(1)
+
+    // Ensure we can compare events as strings and maintain the same order
+    const events = [event1, event2, event3, event4]
+    const sortedEvents = [...events].sort()
+    expect(sortedEvents).to.deep.equal(events)
+  })
+})