umap-project 2.6.3__py3-none-any.whl → 2.7.0b0__py3-none-any.whl

umap/static/umap/map.css

@@ -592,17 +592,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 +819,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 +829,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 +847,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 +865,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 +884,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;
@@ -1499,9 +1487,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,158 @@
+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()
+      clock = new HybridLogicalClock(now, 5, 'local')
+      const result = clock.receive(`${now}:7:remote`)
+      expect(result.walltime).to.equal(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)
+      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
+    const remoteEvent = 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)
+  })
+})

umap/static/umap/unittests/sync.js

@@ -5,10 +5,10 @@ import pkg from 'chai'
 const { expect } = pkg
 
 import { MapUpdater } from '../js/modules/sync/updaters.js'
-import { SyncEngine } from '../js/modules/sync/engine.js'
+import { SyncEngine, Operations } from '../js/modules/sync/engine.js'
 
 describe('SyncEngine', () => {
-  it('should initialize methods even before start', function () {
+  it('should initialize methods even before start', () => {
     const engine = new SyncEngine({})
     engine.upsert()
     engine.update()
@@ -16,8 +16,8 @@ describe('SyncEngine', () => {
   })
 })
 
-describe('#dispatch', function () {
-  it('should raise an error on unknown updater', function () {
+describe('#dispatch', () => {
+  it('should raise an error on unknown updater', () => {
     const dispatcher = new SyncEngine({})
     expect(() => {
       dispatcher.dispatch({
@@ -27,7 +27,7 @@ describe('#dispatch', function () {
       })
     }).to.throw(Error)
   })
-  it('should produce an error on malformated messages', function () {
+  it('should produce an error on malformated messages', () => {
     const dispatcher = new SyncEngine({})
     expect(() => {
       dispatcher.dispatch({
@@ -36,7 +36,7 @@ describe('#dispatch', function () {
       })
     }).to.throw(Error)
   })
-  it('should raise an unknown operations', function () {
+  it('should raise an unknown operations', () => {
     const dispatcher = new SyncEngine({})
     expect(() => {
       dispatcher.dispatch({
@@ -47,55 +47,55 @@ describe('#dispatch', function () {
 })
 
 describe('Updaters', () => {
-  describe('BaseUpdater', function () {
+  describe('BaseUpdater', () => {
     let updater
     let map
     let obj
 
-    this.beforeEach(function () {
+    beforeEach(() => {
       map = {}
       updater = new MapUpdater(map)
       obj = {}
     })
-    it('should be able to set object properties', function () {
+    it('should be able to set object properties', () => {
       let obj = {}
       updater.updateObjectValue(obj, 'foo', 'foo')
       expect(obj).deep.equal({ foo: 'foo' })
     })
 
-    it('should be able to set object properties recursively on existing objects', function () {
+    it('should be able to set object properties recursively on existing objects', () => {
       let obj = { foo: {} }
       updater.updateObjectValue(obj, 'foo.bar', 'foo')
       expect(obj).deep.equal({ foo: { bar: 'foo' } })
     })
 
-    it('should be able to set object properties recursively on deep objects', function () {
+    it('should be able to set object properties recursively on deep objects', () => {
       let obj = { foo: { bar: { baz: {} } } }
       updater.updateObjectValue(obj, 'foo.bar.baz.test', 'value')
       expect(obj).deep.equal({ foo: { bar: { baz: { test: 'value' } } } })
     })
 
-    it('should be able to replace object properties recursively on deep objects', function () {
+    it('should be able to replace object properties recursively on deep objects', () => {
       let obj = { foo: { bar: { baz: { test: 'test' } } } }
       updater.updateObjectValue(obj, 'foo.bar.baz.test', 'value')
       expect(obj).deep.equal({ foo: { bar: { baz: { test: 'value' } } } })
     })
 
-    it('should not set object properties recursively on non-existing objects', function () {
+    it('should not set object properties recursively on non-existing objects', () => {
       let obj = { foo: {} }
       updater.updateObjectValue(obj, 'bar.bar', 'value')
 
       expect(obj).deep.equal({ foo: {} })
     })
 
-    it('should delete keys for undefined values', function () {
+    it('should delete keys for undefined values', () => {
       let obj = { foo: 'foo' }
       updater.updateObjectValue(obj, 'foo', undefined)
 
       expect(obj).deep.equal({})
     })
 
-    it('should delete keys for undefined values, recursively', function () {
+    it('should delete keys for undefined values, recursively', () => {
       let obj = { foo: { bar: 'bar' } }
       updater.updateObjectValue(obj, 'foo.bar', undefined)
 
@@ -103,3 +103,309 @@ describe('Updaters', () => {
     })
   })
 })
+
+describe('Operations', () => {
+  describe('haveSameContext', () => {
+    const createOperation = (overrides = {}) => ({
+      subject: 'feature',
+      metadata: {
+        id: 'UxNjQ',
+        layerId: '606d26bd-230f-4d3e-a2a7-0c3caed71548',
+        featureType: 'marker',
+      },
+      ...overrides,
+    })
+
+    it('should check if subject and metadata are the same', () => {
+      const op1 = createOperation()
+      const op2 = createOperation()
+      const op3 = createOperation({
+        subject: 'datalayer',
+        metadata: { id: '606d26bd-230f-4d3e-a2a7-0c3caed71548' },
+      })
+
+      expect(Operations.haveSameContext(op1, op2)).to.be.true
+      expect(Operations.haveSameContext(op1, op3)).to.be.false
+      expect(Operations.haveSameContext(op2, op3)).to.be.false
+    })
+
+    it('should check if the key matches if there is any provided', () => {
+      const op1 = createOperation({ key: 'properties.name' })
+      const op2 = createOperation({ key: 'properties.name' })
+      const op3 = createOperation({ key: 'geometry' })
+      const op4 = createOperation()
+
+      expect(Operations.haveSameContext(op1, op2)).to.be.true
+      expect(Operations.haveSameContext(op1, op3)).to.be.false
+      expect(Operations.haveSameContext(op1, op4)).to.be.true
+      expect(Operations.haveSameContext(op4, createOperation())).to.be.true
+    })
+
+    it('should use deep equality for subject and metadata', () => {
+      const op1 = createOperation({ metadata: { nested: { value: 1 } } })
+      const op2 = createOperation({ metadata: { nested: { value: 1 } } })
+      const op3 = createOperation({ metadata: { nested: { value: 2 } } })
+
+      expect(Operations.haveSameContext(op1, op2)).to.be.true
+      expect(Operations.haveSameContext(op1, op3)).to.be.false
+    })
+  })
+
+  describe('sort', () => {
+    it('should sort operations by timestamp', () => {
+      const operations = [
+        { hlc: '1727193550:44:id1' },
+        { hlc: '1727193549:42:id1' },
+        { hlc: '1727193551:43:id1' },
+      ]
+      const sorted = Operations.sort(operations)
+      expect(sorted).to.deep.equal([
+        { hlc: '1727193549:42:id1' },
+        { hlc: '1727193550:44:id1' },
+        { hlc: '1727193551:43:id1' },
+      ])
+    })
+
+    it('should sort operations by NN when timestamp is the same', () => {
+      const operations = [
+        { hlc: '1727193549:42:id1' },
+        { hlc: '1727193549:44:id1' },
+        { hlc: '1727193549:43:id1' },
+      ]
+      const sorted = Operations.sort(operations)
+      expect(sorted).to.deep.equal([
+        { hlc: '1727193549:42:id1' },
+        { hlc: '1727193549:43:id1' },
+        { hlc: '1727193549:44:id1' },
+      ])
+    })
+
+    it('should sort operations by id if other fields are equal', () => {
+      const operations = [
+        { hlc: '1727193549:42:id3' },
+        { hlc: '1727193549:42:id2' },
+        { hlc: '1727193549:42:id1' },
+      ]
+      const sorted = Operations.sort(operations)
+      expect(sorted).to.deep.equal([
+        { hlc: '1727193549:42:id1' },
+        { hlc: '1727193549:42:id2' },
+        { hlc: '1727193549:42:id3' },
+      ])
+    })
+  })
+
+  describe('addLocal', () => {
+    it('should add a local operation with a new hlc', () => {
+      const ops = new Operations()
+      const inputMessage = { verb: 'update', subject: 'test' }
+      const result = ops.addLocal(inputMessage)
+      expect(result).to.have.property('hlc')
+      expect(result.hlc).to.match(/^\d+:\d+:[^:]+$/)
+      expect(result).to.include(inputMessage)
+    })
+  })
+
+  describe('sorted', () => {
+    it('should return sorted operations', () => {
+      const ops = new Operations()
+      ops._operations = [{ hlc: '1727193549:43:id1' }, { hlc: '1727193549:42:id1' }]
+      const sorted = ops.sorted()
+      expect(sorted[0].hlc).to.equal('1727193549:42:id1')
+      expect(sorted[1].hlc).to.equal('1727193549:43:id1')
+    })
+  })
+
+  describe('shouldBypassOperation', () => {
+    let ops
+
+    beforeEach(() => {
+      ops = new Operations()
+    })
+
+    const createOperation = (overrides = {}) => ({
+      verb: 'update',
+      subject: 'feature',
+      metadata: {
+        id: 'UxNjQ',
+        layerId: '606d26bd-230f-4d3e-a2a7-0c3caed71548',
+        featureType: 'marker',
+      },
+      key: 'properties.name',
+      value: 'default',
+      hlc: '0000000000000:0:f4df51cc-7617-4bd4-8bd2-599cdf17da65',
+      ...overrides,
+    })
+
+    const createUpsertOperation = (overrides = {}) =>
+      createOperation({
+        verb: 'upsert',
+        key: undefined,
+        value: {
+          type: 'Feature',
+          geometry: {
+            coordinates: [0.439453, 48.04871],
+            type: 'Point',
+          },
+          properties: {},
+          id: 'UxNjQ',
+        },
+        ...overrides,
+      })
+
+    it('should return false if no local operation is newer', () => {
+      const remote = createUpsertOperation({ hlc: '1727184449050:44:id2' })
+      ops._operations = [
+        createOperation({
+          hlc: '1727184449010:0:f4df51cc-7617-4bd4-8bd2-599cdf17da65',
+        }),
+        createUpsertOperation({
+          hlc: '1727184449020:0:b4a221a0-7b62-4588-a6af-041b041006dc',
+        }),
+      ]
+
+      const result = ops.shouldBypassOperation(remote)
+      expect(result).to.be.false
+    })
+
+    it('should return true if a similar "delete" operation is newer', () => {
+      const remote = createOperation({
+        verb: 'delete',
+        metadata: { id: 'M1NTA', layerId: '1234', featureType: 'marker' },
+        hlc: '1:0:3f45b56f-f750-4b50-90d7-9ecce4b0cf53',
+      })
+
+      ops._operations = [
+        createOperation({
+          verb: 'delete',
+          metadata: { id: 'M1NTA', layerId: '1234', featureType: 'marker' },
+          hlc: '2:0:3f45b56f-f750-4b50-90d7-9ecce4b0cf53',
+        }),
+      ]
+
+      const result = ops.shouldBypassOperation(remote)
+      expect(result).to.be.true
+    })
+
+    describe('update', () => {
+      it('should check for related updates', () => {
+        ops._operations = [
+          createOperation({
+            value: 'y',
+            hlc: '1:0:f4df51cc-7617-4bd4-8bd2-599cdf17da65',
+          }),
+          createOperation({
+            value: 'youpi',
+            hlc: '9:0:f4df51cc-7617-4bd4-8bd2-599cdf17da65',
+          }),
+        ]
+
+        const remoteOperation = createOperation({
+          value: 'something else',
+          hlc: '0:0:f4df51cc-7617-4bd4-8bd2-599cdf17da65',
+        })
+
+        const result = ops.shouldBypassOperation(remoteOperation)
+        expect(result).to.be.true
+      })
+
+      it('should check for related deletes', () => {
+        ops._operations = [
+          {
+            verb: 'delete',
+            subject: 'feature',
+            metadata: {
+              id: 'M1NTA',
+              layerId: '123',
+              featureType: 'marker',
+            },
+            hlc: '1727196583562:0:3f45b56f-f750-4b50-90d7-9ecce4b0cf53',
+            key: undefined,
+          },
+        ]
+
+        const remoteOperation = createOperation({
+          metadata: { id: 'M1NTA', layerId: '123', featureType: 'marker' },
+          key: 'geometry',
+          value: { coordinates: [2.944336, 47.070122], type: 'Point' },
+          hlc: '0:0:3f45b56f-f750-4b50-90d7-9ecce4b0cf53',
+        })
+
+        const result = ops.shouldBypassOperation(remoteOperation)
+        expect(result).to.be.true
+      })
+    })
+
+    describe('upsert', () => {
+      it('should take precedence over updates (even if fresher)', () => {
+        ops._operations = [
+          createOperation({
+            value: 'youpi',
+            hlc: '1000000000000:0:f4df51cc-7617-4bd4-8bd2-599cdf17da65',
+          }),
+        ]
+
+        const remoteOperation = createUpsertOperation({
+          hlc: '0000000000000:0:b4a221a0-7b62-4588-a6af-041b041006dc',
+        })
+
+        const result = ops.shouldBypassOperation(remoteOperation)
+        expect(result).to.be.false
+      })
+    })
+
+    describe('delete', () => {
+      it('should check for the same delete', () => {
+        ops._operations = [
+          createOperation({
+            verb: 'delete',
+            metadata: { id: 'I3MDg', layerId: null, featureType: 'polygon' },
+            key: undefined,
+            hlc: '1:0:3f45b56f-f750-4b50-90d7-9ecce4b0cf53',
+          }),
+        ]
+
+        const remoteOperation = createOperation({
+          verb: 'delete',
+          metadata: { id: 'I3MDg', layerId: null, featureType: 'polygon' },
+          key: undefined,
+          hlc: '0:0:3f45b56f-f750-4b50-90d7-9ecce4b0cf53',
+        })
+
+        const result = ops.shouldBypassOperation(remoteOperation)
+        expect(result).to.be.true
+      })
+    })
+  })
+  describe('storeRemoteOperations', () => {
+    it('should store remote operations and update the local HLC', () => {
+      const ops = new Operations()
+      const remoteOps = [{ hlc: '1727193549:42:id2' }, { hlc: '1727193549:43:id2' }]
+      ops.storeRemoteOperations(remoteOps)
+      expect(ops._operations).to.deep.equal(remoteOps)
+    })
+  })
+
+  describe('getOperationsSince', () => {
+    it('should return operations since a given HLC', () => {
+      const ops = new Operations()
+      ops._operations = [
+        { hlc: '1727193549:42:id1' },
+        { hlc: '1727193549:43:id1' },
+        { hlc: '1727193549:44:id1' },
+      ]
+      const result = ops.getOperationsSince('1727193549:42:id1')
+      expect(result).to.deep.equal([
+        { hlc: '1727193549:43:id1' },
+        { hlc: '1727193549:44:id1' },
+      ])
+    })
+
+    it('should return all operations if no HLC is provided', () => {
+      const ops = new Operations()
+      ops._operations = [{ hlc: '1727193549:42:id1' }, { hlc: '1727193549:43:id1' }]
+      const result = ops.getOperationsSince()
+      expect(result).to.deep.equal(ops._operations)
+    })
+  })
+})

umap/static/umap/unittests/utils.js

@@ -779,4 +779,27 @@ describe('Utils', () => {
       )
     })
   })
+
+  describe('#isObject', () => {
+    it('should return true for objects', () => {
+      assert.equal(Utils.isObject({}), true)
+      assert.equal(Utils.isObject({ foo: 'bar' }), true)
+    })
+
+    it('should return false for Array', () => {
+      assert.equal(Utils.isObject([]), false)
+    })
+
+    it('should return false on null', () => {
+      assert.equal(Utils.isObject(null), false)
+    })
+
+    it('should return false on undefined', () => {
+      assert.equal(Utils.isObject(undefined), false)
+    })
+
+    it('should return false on string', () => {
+      assert.equal(Utils.isObject(''), false)
+    })
+  })
 })