@cocreate/elements 1.45.0 → 1.48.0

package/test/deferred-src.test.cjs

@@ -0,0 +1,11 @@
+const {test}=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const vm=require('node:vm');
+const source=fs.readFileSync(require.resolve('../src/srcHandler.js'),'utf8');
+test('deferred SSR source fetches, renders and clears its 304 marker',async()=>{
+ const attrs=new Map([['src','/component.html'],['error','304']]);let content,requests=0;
+ const el={tagName:'DIV',getAttribute:key=>attrs.get(key)??null,hasAttribute:key=>attrs.has(key),removeAttribute:key=>attrs.delete(key),setValue:value=>{content=value;}};
+ const init=vm.runInNewContext(source.slice(source.indexOf('async function initElements('),source.indexOf('async function initMediaSource('))+'\ninitElements',{initializing:new WeakMap(),isSameOrigin:()=>true,sessionStorage:{getItem:()=>null},fetch:async()=>{requests++;return {status:200,ok:true,text:async()=>'<p>Cached or fetched content</p>'};},console,ObjectId:()=>''});
+ await init([el]);assert.equal(requests,1);assert.equal(content,'<p>Cached or fetched content</p>');assert.equal(attrs.has('error'),false);
+});

package/test/form-enter.test.cjs

@@ -0,0 +1,48 @@
+const assert = require('node:assert/strict');
+const { readFileSync } = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const test = require('node:test');
+const source = readFileSync(path.join(__dirname, '../src/formHandler.js'), 'utf8');
+const handler = source.slice(source.indexOf('function handleEnter('), source.indexOf('\n/**\n * @param form'));
+function run(options = {}) {
+    let clicked = 0, prevented = 0, queried = 0;
+    const form = { contains: () => true };
+    const scope = { getAttribute: () => '#next' };
+    const target = {
+        form, hasAttribute: () => true,
+        matches: () => options.disabled || false,
+        closest: () => options.hidden ? {} : null,
+        getClientRects: () => options.invisible ? [] : [{}],
+        click: () => clicked++
+    };
+    const input = {
+        tagName: options.tagName || 'INPUT', type: options.type || 'text', form,
+        closest: selector => selector === '[submit-query]' ? (options.noQuery ? null : scope) : (options.widget ? {} : null)
+    };
+    const event = { key: 'Enter', target: input, currentTarget: form, preventDefault: () => prevented++, ...options.event };
+    vm.runInNewContext(handler + '\nhandleEnter(event);', {
+        event, getComputedStyle: () => ({ visibility: 'visible' }),
+        queryElements: ({ element }) => { assert.equal(element, scope); queried++; return options.multiple ? [target, target] : [target]; }
+    });
+    return { clicked, prevented, queried };
+}
+test('an explicit query clicks its target once', () => {
+    assert.deepEqual(run(), { clicked: 1, prevented: 1, queried: 1 });
+});
+test('without a query, native behavior is left alone', () => {
+    assert.deepEqual(run({noQuery:true}), {clicked:0,prevented:0,queried:0});
+});
+for (const option of ['disabled','hidden','invisible','multiple']) {
+    test(`${option} targets are not clicked and cannot fall through to submission`, () => {
+        const result=run({[option]:true}); assert.equal(result.clicked,0);assert.equal(result.prevented,1);
+    });
+}
+for (const options of [{tagName:'TEXTAREA'},{tagName:'SELECT'},{type:'checkbox'},{type:'submit'},{widget:true},{event:{isComposing:true}},{event:{ctrlKey:true}},{event:{defaultPrevented:true}}]) {
+    test(`preserves control behavior: ${JSON.stringify(options)}`,()=>{
+        assert.deepEqual(run(options),{clicked:0,prevented:0,queried:0});
+    });
+}
+test('held Enter does not repeat or fall through to native submission',()=>{
+    assert.deepEqual(run({event:{repeat:true}}),{clicked:0,prevented:1,queried:0});
+});

package/test/get-data.test.cjs

@@ -0,0 +1,100 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const vm = require('node:vm');
+
+async function setup() {
+    const context = vm.createContext({
+        localStorage: { getItem: () => null }
+    });
+    const registries = {
+        elements: new Map(),
+        forms: new Map(),
+        keys: new Map(),
+        elementSubscriptions: new Map(),
+        subscriptions: new Map()
+    };
+    const stubs = {
+        '@cocreate/utils': {
+            getAttributes: element => ({ ...element.data }),
+            checkValue: () => true
+        },
+        'mapRegistry.js': registries,
+        'subscribeHandler.js': { getSubscription: () => null },
+        'crudHandler.js': { read() {}, save() {} }
+    };
+    const modules = new Map();
+
+    function load(name) {
+        name = name.startsWith('./') ? name.slice(2) : name;
+        if (modules.has(name)) return modules.get(name);
+
+        const stub = stubs[name];
+        const module = stub
+            ? new vm.SyntheticModule(Object.keys(stub), function () {
+                for (const [key, value] of Object.entries(stub)) {
+                    this.setExport(key, value);
+                }
+            }, { context })
+            : new vm.SourceTextModule(
+                fs.readFileSync(path.join(__dirname, '../src', name), 'utf8'),
+                { context, identifier: name }
+            );
+        modules.set(name, module);
+        return module;
+    }
+
+    const module = load('getDataHandler.js');
+    await module.link(load);
+    await module.evaluate();
+    return module.namespace;
+}
+
+function field(form, key, value) {
+    return {
+        data: { array: 'organizations', object: '', key },
+        form,
+        attributes: [],
+        closest: () => form,
+        getAttribute: name => name === 'key' ? key : null,
+        hasAttribute: name => name === 'key',
+        getValue: async () => value,
+        matches: selector => selector !== '[render-query]' && selector !== 'input[type="file"]'
+    };
+}
+
+test('getData preserves each field key when controls share an object scope', async () => {
+    const { getData, getDataObject, initDataKey } = await setup();
+    const form = { elements: [] };
+    const fields = [
+        field(form, 'name', 'Acme'),
+        field(form, '_id', 'org-1'),
+        field(form, 'key', 'secret')
+    ];
+    form.elements = fields;
+    for (const element of fields) initDataKey(element, getDataObject(element));
+
+    const [payload] = await getData(form);
+    assert.deepEqual(
+        JSON.parse(JSON.stringify(payload.object)),
+        { name: 'Acme', _id: 'org-1', key: 'secret' }
+    );
+});
+
+test('getData does not apply a whole-object key to neighboring fields', async () => {
+    const { getData, getDataObject, initDataKey } = await setup();
+    const form = { elements: [] };
+    const fields = [
+        field(form, '{}', { name: 'Acme' }),
+        field(form, '_id', 'org-1')
+    ];
+    form.elements = fields;
+    for (const element of fields) initDataKey(element, getDataObject(element));
+
+    const [payload] = await getData(form);
+    assert.deepEqual(
+        JSON.parse(JSON.stringify(payload.object)),
+        { name: 'Acme', _id: 'org-1' }
+    );
+});

package/test/init-read.test.cjs

@@ -0,0 +1,145 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const test = require('node:test');
+
+async function setup() {
+    const requests = [], jobs = new Map(), errors = [], observers = [];
+    let timerId = 0;
+    const context = vm.createContext({
+        console: { error: (...args) => errors.push(args), log() {} },
+        document: { querySelectorAll: () => [] },
+        localStorage: { getItem: () => null },
+        HTMLCollection: class {}, NodeList: class {},
+        setTimeout: (callback) => { jobs.set(++timerId, callback); return timerId; },
+        clearTimeout: (id) => jobs.delete(id)
+    });
+    const stubs = {
+        '@cocreate/observer': { default: { init(options) { observers.push(options); } } },
+        '@cocreate/actions': { default: { init() {} } },
+        '@cocreate/socket-client': { default: { send() {} } },
+        '@cocreate/crud-client': { default: { listen() {}, send: async (data) => { requests.push(data); } } },
+        '@cocreate/filter': { default: { init: async (element) => { if (element.ready) await element.ready; } } },
+        '@cocreate/utils': {
+            getAttributes: (element) => ({ ...element.data }),
+            getAttributeNames: () => [], queryElements: () => [],
+            checkValue: (value) => !/{{.*}}/.test(value)
+        },
+        'setDataHandler.js': { setData() {}, setDataType() {} }
+    };
+    const modules = new Map();
+    function load(name) {
+        name = name.startsWith('./') ? name.slice(2) : name;
+        if (modules.has(name)) return modules.get(name);
+        const stub = stubs[name];
+        const module = stub
+            ? new vm.SyntheticModule(Object.keys(stub), function () {
+                for (const [key, value] of Object.entries(stub)) this.setExport(key, value);
+            }, { context })
+            : new vm.SourceTextModule(fs.readFileSync(path.join(__dirname, '../src', name), 'utf8'), { context, identifier: name });
+        modules.set(name, module);
+        return module;
+    }
+    const module = load('initHandler.js');
+    await module.link(load);
+    await module.evaluate();
+    return {
+        init: module.namespace.init, requests, errors, observers,
+        flush() { const batch = [...jobs.values()]; jobs.clear(); for (const job of batch) job(); }
+    };
+}
+function element(id, attributes = {}) {
+    return {
+        tagName: 'DIV', data: { array: 'apis', object: id, key: 'name' },
+        getAttribute: (key) => attributes[key] ?? null,
+        hasAttribute: (key) => Object.hasOwn(attributes, key),
+        addEventListener() {}
+    };
+}
+const tick = () => new Promise(resolve => setImmediate(resolve));
+
+test('filtered counts for different clusters are read in separate batches', async () => {
+    const f = await setup();
+    const counts = ['cluster-a', 'cluster-b'].map(cluster => {
+        const el = element('');
+        el.data = { array: 'servers', object: '', key: '$length' };
+        el.getFilter = async () => ({ query: { cluster_id: cluster }, index: 0 });
+        return el;
+    });
+    await f.init(counts);
+    f.flush();
+    assert.equal(f.requests.length, 2);
+    assert.deepEqual(f.requests.map(data => data.filter.query.cluster_id), ['cluster-a', 'cluster-b']);
+});
+
+test('a pending field does not block reads for ready elements in the same SSR page', async () => {
+    const f = await setup();
+    const slow = element('111111111111111111111111');
+    const ready = element('222222222222222222222222', { rendered: 'true' });
+    let release;
+    slow.ready = new Promise(resolve => { release = resolve; });
+    const pending = f.init([slow, ready]);
+    await tick();
+    f.flush();
+    try {
+        assert.equal(f.requests.length, 1);
+        assert.equal(f.requests[0].object._id, ready.data.object);
+    } finally {
+        release();
+        await pending;
+    }
+    f.flush();
+    assert.equal(f.requests.length, 2);
+});
+
+test('one failed initialization does not prevent other reads and can be retried', async () => {
+    const f = await setup();
+    const broken = element('111111111111111111111111');
+    const ready = element('222222222222222222222222');
+    broken.ready = Promise.reject(new Error('value lookup failed'));
+    await f.init([broken, ready]);
+    f.flush();
+    assert.equal(f.requests.length, 1);
+    assert.equal(f.errors.length, 1);
+    delete broken.ready;
+    await f.init(broken);
+    f.flush();
+    assert.equal(f.requests.length, 2);
+});
+
+test('ready fields for the same document still share one debounced read', async () => {
+    const f = await setup();
+    await f.init([element('111111111111111111111111'), element('111111111111111111111111')]);
+    f.flush();
+    assert.equal(f.requests.length, 1);
+});
+
+test('read=false and already read elements remain excluded', async () => {
+    const f = await setup();
+    const read = element('222222222222222222222222');
+    read.hasRead = true;
+    await f.init([element('111111111111111111111111', { read: 'false' }), read]);
+    f.flush();
+    assert.equal(f.requests.length, 0);
+});
+
+test('changing read from false to true reads the current composed filter', async () => {
+    const f = await setup();
+    const attributes = { read: 'false' };
+    const el = element('', attributes);
+    el.data = { array: 'files', object: '', key: '' };
+    el.getFilter = async () => ({ query: { path: '/' }, index: 0 });
+
+    await f.init(el);
+    f.flush();
+    assert.equal(f.requests.length, 0);
+
+    attributes.read = 'true';
+    const observer = f.observers.find(item => item.name === 'CoCreateElementsReadAttribute');
+    await observer.callback({ target: el, oldValue: 'false' });
+    f.flush();
+
+    assert.equal(f.requests.length, 1);
+    assert.equal(f.requests[0].filter.query.path, '/');
+});

package/test/load-more.test.cjs

@@ -0,0 +1,19 @@
+const {test}=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const vm=require('node:vm');
+const source=fs.readFileSync(require.resolve('../src/setDataHandler.js'),'utf8');
+const loadMore=vm.runInNewContext('('+source.slice(source.indexOf('async function loadMore('),source.indexOf('\nasync function checkFilters'))+')');
+test('append deduplicates without mutating shared cache/server responses',async()=>{
+ const response={object:[{_id:'a'},{_id:'b'},{_id:'b'}],filter:{index:3,startingIndex:1}};
+ const original=JSON.stringify(response);let rendered;
+ await loadMore({getData:async()=>({object:[{_id:'a'}]}),renderValue:async data=>{rendered=data;}},response,'object');
+ assert.equal(JSON.stringify(response),original);
+ assert.equal(rendered.object.length,1);assert.equal(rendered.object[0]._id,'b');
+ assert.equal(rendered.filter.loadMore,true);assert.equal(rendered.filter.overwrite,false);
+});
+test('duplicate-only response leaves existing render untouched',async()=>{
+ let called=false;
+ await loadMore({getData:async()=>({object:[{_id:'a'}]}),renderValue:async()=>{called=true;}},{object:[{_id:'a'}]},'object');
+ assert.equal(called,false);
+});

package/test/save-array.test.cjs

@@ -0,0 +1,31 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const vm = require('node:vm');
+
+const source = fs.readFileSync(require.resolve('../src/crudHandler.js'), 'utf8');
+const saveSource = source.slice(source.indexOf('export async function save('), source.indexOf('\nActions.init(')).replace('export ', '');
+
+for (const value of [[{ name: 'image.svg' }], [{ name: 'a.svg' }, { name: 'b.svg' }], { name: 'image.svg' }]) {
+    test(`saving an entire document preserves its shape: ${JSON.stringify(value)}`, async () => {
+        let sent;
+        const element = {
+            tagName: 'INPUT',
+            getAttribute: name => name === 'key' ? '{}' : null,
+            getValue: async () => value,
+            setAttribute() {}
+        };
+        const save = vm.runInNewContext(`(${saveSource})`, {
+            elements: new Map([[element, 'files']]),
+            keys: new Map([['files', { dataKey: { object: { type: 'object', array: 'files', object: '', key: '{}' } } }]]),
+            getSubscription: () => null,
+            deriveSubscriptionKeys: () => [],
+            CRUD: { send: async data => { sent = data; } }
+        });
+        await save(element);
+        assert.equal(Array.isArray(sent.object), Array.isArray(value));
+        assert.equal(JSON.stringify(sent.object), JSON.stringify(value));
+        assert.equal(sent.method, 'object.create');
+        if (Array.isArray(value)) assert.notEqual(sent.object, value);
+    });
+}

package/test/save-completion.test.cjs

@@ -0,0 +1,36 @@
+const assert = require('node:assert/strict');
+const { readFileSync } = require('node:fs');
+const { join } = require('node:path');
+const vm = require('node:vm');
+const test = require('node:test');
+
+test('save waits for the response to be applied before its caller continues', async () => {
+    const source = readFileSync(join(__dirname, '../src/crudHandler.js'), 'utf8');
+    const saveCode = source.slice(source.indexOf('export async function save('), source.indexOf('\nActions.init(')).replace('export ', '');
+    let finishApplying;
+    let applied = false;
+    let completed = false;
+    const gate = new Promise(resolve => { finishApplying = resolve; });
+    const form = {
+        tagName: 'FORM',
+        getAttribute: () => null,
+        setAttribute() {},
+        getData: async () => [{ type: 'object', array: 'clusters', object: { name: 'Cluster' } }]
+    };
+    const save = vm.runInNewContext(`(${saveCode})`, {
+        getSubscription: () => null,
+        deriveSubscriptionKeys: () => [],
+        CRUD: { send: async () => ({
+            type: 'object', method: 'object.create', array: 'clusters',
+            object: [{ _id: '65f8cb447b39a3c1a8904e22' }]
+        }) },
+        setDataType: async () => { await gate; applied = true; }
+    });
+    const completion = save(form).then(() => { completed = true; });
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(completed, false);
+    finishApplying();
+    await completion;
+    assert.equal(applied, true);
+    assert.equal(completed, true);
+});

package/test/set-data-type.test.cjs

@@ -0,0 +1,119 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const vm = require("node:vm");
+const test = require("node:test");
+
+async function loadSetDataType(watchedElements = []) {
+    const context = vm.createContext({
+        console,
+        HTMLCollection: class {},
+        CustomEvent: class {
+            constructor(name, options) {
+                this.name = name;
+                this.detail = options?.detail;
+            }
+        }
+    });
+    const source = fs.readFileSync(
+        path.join(__dirname, "../src/setDataHandler.js"),
+        "utf8"
+    );
+    const module = new vm.SourceTextModule(source, { context });
+    const modules = {
+        "@cocreate/utils": {
+            dotNotationToObject: value => value,
+            queryData: () => true,
+            searchData: () => true,
+            sortData: value => value,
+            getAttributes: element => ({ key: element.getAttribute('key') }),
+            checkValue: () => true,
+            getValueFromObject: () => undefined
+        },
+        "@cocreate/crud-client": { default: { getValueFromObject: (object, key) => object[key] } },
+        "@cocreate/filter": { default: { filters: new Map() } },
+        "./mapRegistry.js": {
+            elements: new WeakMap(),
+            forms: new WeakMap(),
+            keys: new Map()
+        },
+        "./getDataHandler.js": {
+            getDataElements: () => watchedElements,
+            getDataObject: () => undefined
+        }
+    };
+
+    await module.link(name => new vm.SyntheticModule(
+        Object.keys(modules[name]),
+        function () {
+            for (const [key, value] of Object.entries(modules[name])) {
+                this.setExport(key, value);
+            }
+        },
+        { context }
+    ));
+    await module.evaluate();
+    return module.namespace.setDataType;
+}
+
+test("setDataType tolerates a form that has not entered the registry yet", async () => {
+    const setDataType = await loadSetDataType();
+    const attributes = { array: "apis", object: "pending" };
+    const form = {
+        tagName: "FORM",
+        querySelectorAll: () => [],
+        getAttribute: name => attributes[name] ?? null,
+        hasAttribute: name => Object.hasOwn(attributes, name),
+        setAttribute: (name, value) => {
+            attributes[name] = value;
+        }
+    };
+
+    await assert.doesNotReject(() => setDataType(form, {
+        type: "object",
+        object: [{
+            _id: "6abb2ce702c3c7e6fbec0215",
+            $array: "apis"
+        }]
+    }, { element: { dispatchEvent() {} } }));
+    assert.equal(attributes.object, "6abb2ce702c3c7e6fbec0215");
+});
+
+test('saved is dispatched only after response fields following async work are updated', async () => {
+    let release;
+    let idValue = '';
+    const gate = new Promise(resolve => { release = resolve; });
+    const watcher = attributes => ({
+        hasAttribute: name => Object.hasOwn(attributes, name),
+        getAttribute: name => attributes[name] ?? null,
+        querySelector: () => null,
+        dispatchEvent() {}
+    });
+    const renderer = watcher({ 'render-query': 'template' });
+    renderer.renderValue = async () => {};
+    renderer.getData = () => gate;
+    const idField = watcher({ key: '_id' });
+    idField.setValue = value => { idValue = value; };
+    const setDataType = await loadSetDataType([renderer, idField]);
+    const attributes = { array: 'clusters', object: 'pending' };
+    const form = {
+        tagName: 'FORM',
+        querySelectorAll: () => [],
+        hasAttribute: name => Object.hasOwn(attributes, name),
+        getAttribute: name => attributes[name] ?? null,
+        setAttribute: (name, value) => { attributes[name] = value; }
+    };
+    const id = '65f8cb447b39a3c1a8904e22';
+    const savedIds = [];
+    const completion = setDataType(form, {
+        type: 'object', method: 'object.create', array: 'clusters',
+        object: [{ _id: id, $array: 'clusters' }]
+    }, { element: { dispatchEvent: () => savedIds.push(idValue) } });
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(idValue, '');
+    assert.deepEqual(savedIds, []);
+    release();
+    await completion;
+    assert.equal(idValue, id);
+    assert.deepEqual(savedIds, [id]);
+});

package/test/ssr-response.test.cjs

@@ -0,0 +1,108 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const test = require('node:test');
+
+async function loadSetData() {
+    const context = vm.createContext({ console, HTMLCollection: class {}, CustomEvent: class {} });
+    const source = fs.readFileSync(path.join(__dirname, '../src/setDataHandler.js'), 'utf8');
+    const module = new vm.SourceTextModule(source, { context });
+    const utils = {
+        dotNotationToObject: value => value, queryData: () => true,
+        searchData: () => true, sortData: value => value,
+        getAttributes: element => ({ key: element.getAttribute('key'), isRead: element.getAttribute('read') }),
+        checkValue: () => true,
+        getValueFromObject: (object, key) => object[key]
+    };
+    const modules = {
+        '@cocreate/utils': utils,
+        '@cocreate/crud-client': { default: { getValueFromObject: (object, key) => object[key] } },
+        '@cocreate/filter': { default: { filters: new Map() } },
+        './mapRegistry.js': { elements: new WeakMap(), forms: new WeakMap(), keys: new Map() },
+        './getDataHandler.js': { getDataElements: () => [], getDataObject: element => ({ object: element.getAttribute('object') }) }
+    };
+    await module.link(name => new vm.SyntheticModule(Object.keys(modules[name]), function () {
+        for (const [key, value] of Object.entries(modules[name])) this.setExport(key, value);
+    }, { context }));
+    await module.evaluate();
+    return module.namespace.setData;
+}
+
+function element(attributes) {
+    return {
+        hasAttribute: name => Object.hasOwn(attributes, name),
+        getAttribute: name => attributes[name] ?? null,
+        removeAttribute: name => delete attributes[name],
+        querySelector: () => null,
+        dispatchEvent() {},
+        values: [],
+        setValue(value) { this.values.push(value); }
+    };
+}
+
+test('SSR app labels do not prevent later table columns from receiving shared data', async () => {
+    const setData = await loadSetData();
+    const id = '28b6ddbe8b35de252ecd79e1';
+    const label = element({ array: 'apps', object: id, key: 'name', rendered: 'true' });
+    const table = element({ array: 'apps', object: id, key: 'fields', 'render-query': "[template='column'][]" });
+    const renders = [];
+    table.renderValue = async data => renders.push(data);
+    const fields = [{ key: 'name', label: 'Name' }, { key: 'type', label: 'Type' }];
+    await setData([label, table], {
+        method: 'object.read', array: 'apps',
+        object: [{ _id: id, $storage: ['mongodb'], name: 'Cluster', fields }]
+    });
+    assert.equal(label.hasAttribute('rendered'), false);
+    assert.deepEqual(label.values, []);
+    assert.equal(renders.length, 1);
+    assert.deepEqual(Array.from(renders[0].fields), fields);
+});
+
+test('filtered counts retain their value during writes and refresh each cluster independently', async () => {
+    const setData = await loadSetData();
+    const counts = ['cluster-a', 'cluster-b'].map(cluster => {
+        const el = element({ array: 'servers', object: '', key: '$length' });
+        el.getFilter = async () => ({ query: { cluster_id: cluster }, index: 0 });
+        el.refreshes = [];
+        el.setFilter = filter => el.refreshes.push(filter);
+        return el;
+    });
+    for (const el of counts) {
+        await setData(el, { method: 'object.read', array: 'servers', object: [{ _id: 'server' }] });
+    }
+    for (const method of ['object.create', 'object.update', 'object.delete']) {
+        await setData(counts, { method, array: 'servers', object: [{ _id: 'server', $update: { cluster_id: 'cluster-b' } }] });
+    }
+    for (let i = 0; i < counts.length; i++) {
+        assert.deepEqual(counts[i].values, [1]);
+        assert.equal(counts[i].refreshes.length, 3);
+        assert.equal(counts[i].refreshes[0].query.cluster_id, ['cluster-a', 'cluster-b'][i]);
+    }
+    await setData(counts[0], { method: 'object.read', array: 'servers', object: [], error: [{ message: 'failed' }] });
+    assert.deepEqual(counts[0].values, [1]);
+    await setData(counts[0], { method: 'object.read', array: 'servers', object: [] });
+    assert.deepEqual(counts[0].values, [1, 0]);
+});
+
+test('unmatched document updates do not write the empty object attribute into a value', async () => {
+    const setData = await loadSetData();
+    const el = element({ array: 'servers', object: '', key: '$length' });
+    el.getFilter = async () => ({});
+    await setData(el, { method: 'object.update', array: 'servers', object: [{ _id: 'other' }] });
+    assert.deepEqual(el.values, []);
+});
+
+test('read=false keeps a deferred value expression intact when a save response arrives', async () => {
+    const setData = await loadSetData();
+    const expression = '$query($closest #provision-workflow #cluster-object-id).getValue()';
+    const el = element({ key: 'cluster_id', read: 'false', value: expression });
+    el.setValue = value => { el.values.push(value); el.value = value; };
+    el.value = expression;
+    await setData(el, {
+        method: 'object.create', array: 'servers',
+        object: [{ _id: 'server', cluster_id: '65f8cb447b39a3c1a8904e22' }]
+    });
+    assert.equal(el.value, expression);
+    assert.deepEqual(el.values, []);
+});

package/webpack.config.js

@@ -48,6 +48,7 @@ module.exports = async (env, argv) => {
 			minimizer: [
 				new EsbuildPlugin({
 					target: "es2017",
+					minify: isProduction,
 					css: true
 				})
 			],