cx 26.0.9 → 26.0.11

package/build/charts/axis/TimeAxis.scss

@@ -1,34 +0,0 @@
-@use "sass:map";
-
-@mixin cx-timeaxis(
-   $name: 'timeaxis',
-   $besm: $cx-besm
-) {
-   $block: map.get($besm, block);
-   $element: map.get($besm, element);
-   $state: map.get($besm, state);
-
-   .#{$block}#{$name} {
-      @include cxb-axis();
-   }
-
-   .#{$element}#{$name}-ticks {
-      @include cxe-axis-ticks();
-   }
-
-   .#{$element}#{$name}-line {
-      @include cxe-axis-line();
-   }
-
-   .#{$element}#{$name}-label {
-      @include cxe-axis-label();
-   }
-
-   .#{$element}#{$name}-label-offset {
-      @include cxe-axis-label-offset();
-   }
-}
-
-@if (cx-should-include('cx/charts/TimeAxis')) {
-   @include cx-timeaxis();
-}

package/build/charts/axis/index.scss

@@ -1,5 +0,0 @@
-
-@import 'Axis';
-@import "NumericAxis";
-@import "CategoryAxis";
-@import "TimeAxis";

package/build/charts/axis/variables.scss

@@ -1,3 +0,0 @@
-
-$cx-axis-line-stroke: rgba(128, 128, 128, 0.2) !default;
-$cx-axis-ticks-stroke: rgba(128, 128, 128, 0.3) !default;

package/build/charts/index.scss

@@ -1,22 +0,0 @@
-@import "axis/index";
-
-@import "PieChart";
-@import "Legend";
-@import "LegendEntry";
-@import "Gridlines";
-@import "Swimlanes";
-@import "Column";
-@import "Bar";
-@import "LineGraph";
-@import "ColumnGraph";
-@import "BarGraph";
-@import "ScatterGraph";
-@import "BubbleGraph";
-@import "Marker";
-@import "MarkerLine";
-@import "Range";
-@import "RangeMarker";
-@import "Swimlane";
-
-//define last for higher priority
-@import "palette";

package/build/charts/palette.scss

@@ -1,97 +0,0 @@
-//https://www.materialui.co/colors
-//normal:200 900
-//hover:100 700
-//selected: 300 900
-//disabled: 0 100
-@use "sass:map";
-@use "sass:list";
-
-$cx-default-palette-colors: rgba(244, 67, 54, 1) rgba(233, 30, 99, 1) rgba(156, 39, 176, 1) rgba(103, 58, 183, 1)
-   rgba(63, 81, 181, 1) rgba(33, 150, 243, 1) rgba(3, 169, 244, 1) rgba(0, 188, 212, 1) rgba(0, 150, 136, 1)
-   rgba(76, 175, 80, 1) rgba(139, 195, 74, 1) rgba(205, 220, 57, 1) rgba(255, 235, 59, 1) rgba(255, 193, 7, 1)
-   rgba(255, 152, 0, 1) rgba(255, 87, 34, 1) !default;
-
-$cx-default-palette-fill-whiten: 60% !default;
-$cx-default-palette-fill-hover-whiten: 50% !default;
-$cx-default-palette-fill-selected-whiten: 20% !default;
-$cx-default-palette-fill-disabled-whiten: 90% !default;
-
-$cx-default-palette-fill-blacken: 0% !default;
-$cx-default-palette-fill-hover-blacken: 0% !default;
-$cx-default-palette-fill-selected-blacken: 0% !default;
-$cx-default-palette-fill-disabled-blacken: 0% !default;
-
-$cx-default-palette-stroke-whiten: 0% !default;
-$cx-default-palette-stroke-blacken: 10% !default;
-
-@mixin cx-palette(
-   $palette-colors: $cx-default-palette-colors,
-   $palette-fill-whiten: $cx-default-palette-fill-whiten,
-   $palette-fill-hover-whiten: $cx-default-palette-fill-hover-whiten,
-   $palette-fill-selected-whiten: $cx-default-palette-fill-selected-whiten,
-   $palette-fill-disabled-whiten: $cx-default-palette-fill-disabled-whiten,
-   $palette-fill-blacken: $cx-default-palette-fill-blacken,
-   $palette-fill-hover-blacken: $cx-default-palette-fill-hover-blacken,
-   $palette-fill-selected-blacken: $cx-default-palette-fill-selected-blacken,
-   $palette-fill-disabled-blacken: $cx-default-palette-fill-disabled-blacken,
-   $palette-stroke-whiten: $cx-default-palette-stroke-whiten,
-   $palette-stroke-blacken: $cx-default-palette-stroke-blacken,
-   $besm: $cx-besm
-) {
-   $block: map.get($besm, block);
-   $element: map.get($besm, element);
-   $state: map.get($besm, state);
-
-   @for $i from 1 through list.length($palette-colors) {
-      $c: list.nth($palette-colors, 1 + (($i - 1) * 1) % list.length($palette-colors));
-
-      .#{$state}color-#{$i - 1} {
-         $fill: cx-blacken(cx-whiten($c, $palette-fill-whiten), $palette-fill-blacken);
-         $stroke: cx-blacken(cx-whiten($fill, $palette-stroke-whiten), $palette-stroke-blacken);
-         fill: $fill;
-         stroke: $stroke;
-         background: $fill;
-         border-color: $stroke;
-
-         &.#{$state}selectable:hover,
-         &.#{$state}selectable.#{$state}hover,
-         .#{$state}color-root:hover &,
-         .#{$state}color-root.#{$state}hover & {
-            $fill: cx-blacken(cx-whiten($c, $palette-fill-hover-whiten), $palette-fill-hover-blacken);
-            $stroke: cx-blacken(cx-whiten($fill, $palette-stroke-whiten), $palette-stroke-blacken);
-            fill: $fill;
-            stroke: $stroke;
-            background: $fill;
-            border-color: $stroke;
-         }
-
-         &.#{$state}selected,
-         &.#{$state}selected:hover,
-         &.#{$state}selected.#{$state}hover,
-         .#{$state}color-root.#{$state}selected &,
-         .#{$state}color-root.#{$state}selected:hover &,
-         .#{$state}color-root.#{$state}selected.#{$state}hover & {
-            $fill: cx-blacken(cx-whiten($c, $palette-fill-selected-whiten), $palette-fill-selected-blacken);
-            $stroke: cx-blacken(cx-whiten($fill, $palette-stroke-whiten), $palette-stroke-blacken);
-            fill: $fill;
-            stroke: $stroke;
-            background: $fill;
-            border-color: $stroke;
-         }
-
-         &.#{$state}disabled,
-         .#{$state}color-root.#{$state}disabled & {
-            $fill: cx-blacken(cx-whiten($c, $palette-fill-disabled-whiten), $palette-fill-disabled-blacken);
-            $stroke: cx-blacken(cx-whiten($fill, $palette-stroke-whiten), $palette-stroke-blacken);
-            fill: $fill;
-            stroke: $stroke;
-            background: $fill;
-            border-color: $stroke;
-         }
-      }
-   }
-}
-
-@if (cx-should-include("cx/charts/palette")) {
-   @include cx-palette();
-}

package/build/charts/variables.scss

@@ -1,22 +0,0 @@
-@use "sass:map";
-@import "axis/variables";
-
-$cx-default-swimlanes-lane-background-color: #f1f1f1;
-$cx-default-range-marker-color: #696969;
-
-$cx-dependencies: map.merge(
-   $cx-dependencies,
-   (
-      "cx/charts/Bar": "cx/charts/palette",
-      "cx/charts/BarGraph": "cx/charts/palette",
-      "cx/charts/Column": "cx/charts/palette",
-      "cx/charts/ColumnGraph": "cx/charts/palette",
-      "cx/charts/LineGraph": "cx/charts/palette",
-      "cx/charts/ColorMap": "cx/charts/palette",
-      "cx/charts/ScatterGraph": "cx/charts/palette",
-      "cx/charts/BubbleGraph": "cx/charts/palette",
-      "cx/charts/MarkerLine": "cx/charts/palette",
-      "cx/charts/Marker": "cx/charts/palette",
-      "cx/charts/PieChart": "cx/charts/palette",
-   )
-);

package/build/data/ArrayElementView.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/data/ArrayElementView.spec.js

@@ -1,81 +0,0 @@
-//@ts-nocheck
-import assert from "assert";
-import { ArrayElementView } from "./ArrayElementView";
-import { getAccessor } from "./getAccessor";
-import { Store } from "./Store";
-describe("ArrayElementView", function () {
-    it("exposes the element as under the $record alias", function () {
-        let letters = [{ letter: "A" }, { letter: "B" }];
-        let store = new Store({ data: { letters } });
-        let elementView = new ArrayElementView({ store, itemIndex: 1, arrayAccessor: getAccessor({ bind: "letters" }) });
-        let record = elementView.get("$record");
-        assert.equal(record, letters[1]);
-    });
-    it("changes of the $record are propagated", function () {
-        let letters = [{ letter: "A" }, { letter: "B" }];
-        let store = new Store({ data: { letters } });
-        let elementView = new ArrayElementView({ store, itemIndex: 1, arrayAccessor: getAccessor({ bind: "letters" }) });
-        elementView.set("$record.letter", "C");
-        assert.deepEqual(store.get("letters"), [letters[0], { letter: "C" }]);
-    });
-    it("removes the element if the $record is deleted", function () {
-        let letters = [{ letter: "A" }, { letter: "B" }];
-        let store = new Store({ data: { letters } });
-        let elementView = new ArrayElementView({ store, itemIndex: 1, arrayAccessor: getAccessor({ bind: "letters" }) });
-        elementView.delete("$record");
-        assert.deepEqual(store.get("letters"), [...letters[0]]);
-    });
-    it("exposes the element as under the given alias", function () {
-        let letters = [{ letter: "A" }, { letter: "B" }];
-        let store = new Store({ data: { letters } });
-        let elementView = new ArrayElementView({
-            store,
-            itemIndex: 1,
-            arrayAccessor: getAccessor({ bind: "letters" }),
-            recordAlias: "$letter",
-        });
-        let record = elementView.get("$letter");
-        assert.equal(record, letters[1]);
-    });
-    it("aliases allow nesting", function () {
-        let letters = [{ letter: "A" }, { letter: "B" }];
-        let store = new Store({ data: { letters } });
-        let elementView = new ArrayElementView({
-            store,
-            itemIndex: 1,
-            arrayAccessor: getAccessor({ bind: "letters" }),
-            recordAlias: "$iter.letter",
-            indexAlias: "$iter.index.letter",
-        });
-        let record = elementView.get("$iter.letter");
-        assert.equal(record, letters[1]);
-        assert.equal(elementView.get("$iter.index.letter"), 1);
-        elementView.set("$iter.letter.letter", "C");
-        assert.equal(store.get("letters.1.letter"), "C");
-    });
-    it("when immutable preserves the parent data object", function () {
-        let letters = [{ letter: "A" }, { letter: "B" }];
-        let store = new Store({ data: { letters } });
-        let elementView = new ArrayElementView({
-            store,
-            itemIndex: 1,
-            arrayAccessor: getAccessor({ bind: "letters" }),
-            immutable: true,
-        });
-        let record = elementView.get("$record");
-        assert.equal(record, letters[1]);
-        assert(!store.getData().hasOwnProperty("$record"));
-    });
-    it("respects the parent's store sealed flag", function () {
-        let letters = [{ letter: "A" }, { letter: "B" }];
-        let store = new Store({ data: { letters }, sealed: true });
-        let elementView = new ArrayElementView({
-            store,
-            itemIndex: 1,
-            arrayAccessor: getAccessor({ bind: "letters" }),
-        });
-        let record = elementView.get("$record");
-        assert.equal(record, letters[1]);
-        assert(!store.getData().hasOwnProperty("$record"));
-    });
-});

package/build/data/Binding.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/data/Binding.spec.js

@@ -1,61 +0,0 @@
-import { Binding } from "./Binding";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-describe("Binding", function () {
-    describe("#get()", function () {
-        it("should get value if value is defined", function () {
-            var state = { person: { name: "Joe" } };
-            var b = Binding.get("person.name");
-            assert.equal(b.value(state), "Joe");
-        });
-        it("allows non-standard property identifiers", function () {
-            var state = { person: { "@schema": "Person" } };
-            var b = Binding.get("person.@schema");
-            assert.equal(b.path, "person.@schema");
-            assert.equal(b.value(state), "Person");
-        });
-        it("properly resolves accessor models", function () {
-            var state = { person: { schema: "Person" } };
-            var b = Binding.get(createAccessorModelProxy("person.schema"));
-            assert.equal(b.value(state), "Person");
-        });
-    });
-    describe("#set()", function () {
-        it("produces new objects along the binding path", function () {
-            var state = { person: { name: "Joe" } };
-            var b = Binding.get("person.name");
-            var ns = b.set(state, "Jack");
-            assert.equal(ns.person.name, "Jack");
-            assert.notEqual(state, ns);
-            assert.notEqual(state.person, ns.person);
-            assert.notEqual(state.person.name, ns.person.name);
-        });
-        it("returns same state object if value does not change", function () {
-            var state = { person: { name: "Joe" } };
-            var b = Binding.get("person.name");
-            var ns = b.set(state, "Joe");
-            assert.equal(state, ns);
-        });
-        it("allows non-standard property identifiers", function () {
-            var state = { person: { "@schema": "Person" } };
-            var b = Binding.get("person.@schema");
-            var ns = b.set(state, "Test");
-            assert.equal(ns.person["@schema"], "Test");
-        });
-    });
-    describe(".delete()", function () {
-        it("correctly removes pointed properties", function () {
-            var state = { person: { name: "Joe" } };
-            var b = Binding.get("person.name");
-            var ns = b.delete(state);
-            assert("person" in ns);
-            assert(!("name" in ns.person));
-        });
-        it("does not change state if property is non-existent", function () {
-            var state = { person: { name: "Joe" } };
-            var b = Binding.get("person.name2");
-            var ns = b.delete(state);
-            assert(ns == state);
-        });
-    });
-});

package/build/data/Expression.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/data/Expression.spec.js

@@ -1,196 +0,0 @@
-import { Expression } from "./Expression";
-import assert from "assert";
-import { StringTemplate } from "./StringTemplate";
-describe("Expression", function () {
-    describe("#compile()", function () {
-        it("returns a selector", function () {
-            let e = Expression.compile("{person.name}");
-            let state = {
-                person: {
-                    name: "Jim",
-                },
-            };
-            assert.equal(e(state), "Jim");
-        });
-        it("ignores bindings in strings", function () {
-            let e = Expression.compile('"{person.name}"');
-            let state = {
-                person: {
-                    name: "Jim",
-                },
-            };
-            assert.equal(e(state), "{person.name}");
-        });
-        it("allows mixed curly braces in strings", () => {
-            let e = Expression.compile('"Hello {" + "person.name}"');
-            assert.equal(e({}), "Hello {person.name}");
-        });
-        it("properly encodes quotes #1", function () {
-            let e = Expression.compile('"\'"');
-            let state = {};
-            assert.equal(e(state), "'");
-        });
-        it("properly encodes quotes #2", function () {
-            let e = Expression.compile('"\\""');
-            let state = {};
-            assert.equal(e(state), '"');
-        });
-        it("properly encodes quotes #3", function () {
-            let e = Expression.compile('"\\\\\\""');
-            let state = {};
-            assert.equal(e(state), '\\"');
-        });
-        it("properly encodes quotes #4", function () {
-            let e = Expression.compile('"\\\\"');
-            let state = {};
-            assert.equal(e(state), "\\");
-        });
-    });
-    describe("allow subexpressions", function () {
-        it("in square brackets", function () {
-            let e = Expression.compile("{[{person.name}]}");
-            let state = {
-                person: {
-                    name: "Jim",
-                },
-            };
-            assert.equal(e(state), "Jim");
-        });
-        it("in square brackets", function () {
-            let e = Expression.compile("{[{person.alias} || {person.name}]}");
-            let state = {
-                person: {
-                    name: "Jim",
-                    alias: "J",
-                },
-            };
-            assert.equal(e(state), "J");
-        });
-        it("prefixed with % sign", function () {
-            let e = Expression.compile("%{1+1}");
-            assert.equal(e({}), "2");
-        });
-        it("can be formatted", function () {
-            let e = Expression.compile("{[1+1]:f;2}");
-            assert.equal(e({}), "2.00");
-        });
-        it("n level deep", function () {
-            let e = Expression.compile("{[{[{[1+1]}]}]:f;2}");
-            assert.equal(e({}), "2.00");
-        });
-        it("with complex math inside", function () {
-            let e = Expression.compile("%{{data}.reduce((a,b)=>a+b, 0):f;2}");
-            let state = {
-                data: [1, 2, 3],
-            };
-            assert.equal(e(state), "6.00");
-        });
-        it("with a conditional operator inside", function () {
-            let e = Expression.compile('{[true ? "T" : "F"]}');
-            assert.equal(e({}), "T");
-        });
-        it("with string interpolation inside", function () {
-            let e = Expression.compile("{[`${{test}}`]}");
-            assert.equal(e({ test: "T" }), "T");
-        });
-    });
-    describe("are working", function () {
-        it("function expressions with get", function () {
-            let e = Expression.get((get) => get("a") + get("b"));
-            assert.equal(e({ a: 1, b: 2 }), 3);
-        });
-        it("are properly memoized", function () {
-            let inv = 0;
-            let e = Expression.get((get) => {
-                inv++;
-                return get("a") + get("b");
-            }).memoize();
-            assert.equal(e({ a: 1, b: 1 }), 2);
-            assert.equal(inv, 1);
-            assert.equal(e({ a: 1, b: 1 }), 2);
-            assert.equal(inv, 1);
-            assert.equal(e({ a: 1, b: 2 }), 3);
-            assert.equal(inv, 2);
-            assert.equal(e({ a: 1, b: 2 }), 3);
-            assert.equal(inv, 2);
-            assert.equal(e({ a: 2, b: 2 }), 4);
-            assert.equal(inv, 3);
-        });
-        it("formatting can be used inside bindings", function () {
-            let e = Expression.get((get) => get("name:prefix;Hello "));
-            assert(e({ name: "CxJS" }), "Hello CxJS");
-        });
-        it("allows using the fmt function inside", function () {
-            let e = Expression.compile('{[fmt({text}, "prefix;Hello ")]}');
-            assert.equal(e({ text: "CxJS" }), "Hello CxJS");
-        });
-        it("allows using dashes inside names", function () {
-            let e = Expression.compile("{framework-name}");
-            assert.equal(e({ "framework-name": "CxJS" }), "CxJS");
-        });
-        it("allows using spaces and other characters inside names", function () {
-            let e = Expression.compile("{1nv@lid js ident1fier}");
-            assert.equal(e({ "1nv@lid js ident1fier": "CxJS" }), "CxJS");
-        });
-        it("allows strings in subexpressions", () => {
-            let e = Expression.compile("{['1']}");
-            assert.equal(e({}), "1");
-            let e2 = Expression.compile('%{"1"}');
-            assert.equal(e({}), "1");
-        });
-        it("allows string templates in nested expressions", () => {
-            Expression.registerHelper("tpl", StringTemplate.format);
-            let e = Expression.compile("tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})");
-            assert.equal(e({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
-            let e2 = Expression.compile("{[tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})]}");
-            assert.equal(e2({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
-            // we're going to need a better parser for this
-            // let e3 = Expression.compile("%{tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})}");
-            // assert.equal(e3({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
-        });
-        it("string templates can be in the data", () => {
-            Expression.registerHelper("tpl", StringTemplate.format);
-            let e = Expression.compile("tpl({template}, {value}, {percentage})");
-            assert.equal(e({ value: 1, percentage: 0.02, template: "{0:n;2} {1:p;2:wrap;(;)}" }), "1.00 (2.00%)");
-        });
-        // it('are properly memoized with proxies', function () {
-        //    let inv = 0;
-        //    let e = Expression.get(d => { inv++; return d.a + d.b}).memoize();
-        //
-        //    assert.equal(e({ a: 1, b: 1 }), 2);
-        //    assert.equal(inv, 1);
-        //
-        //    assert.equal(e({ a: 1, b: 1 }), 2);
-        //    assert.equal(inv, 1);
-        //
-        //    assert.equal(e({ a: 1, b: 2 }), 3);
-        //    assert.equal(inv, 2);
-        //
-        //    assert.equal(e({ a: 1, b: 2 }), 3);
-        //    assert.equal(inv, 2);
-        //
-        //    assert.equal(e({ a: 2, b: 2 }), 4);
-        //    assert.equal(inv, 3);
-        // });
-        //
-        // it('are properly memoized with proxies and deep data', function () {
-        //    let inv = 0;
-        //    let e = Expression.get(d => { inv++; return d.v.a + d.v.b}).memoize();
-        //
-        //    assert.equal(e({ v: { a: 1, b: 1 }}), 2);
-        //    assert.equal(inv, 1);
-        //
-        //    assert.equal(e({ v: { a: 1, b: 1 }}), 2);
-        //    assert.equal(inv, 1);
-        //
-        //    assert.equal(e({ v: { a: 1, b: 2 }}), 3);
-        //    assert.equal(inv, 2);
-        //
-        //    assert.equal(e({ v: { a: 1, b: 2 }}), 3);
-        //    assert.equal(inv, 2);
-        //
-        //    assert.equal(e({ v: { a: 2, b: 2 }}), 4);
-        //    assert.equal(inv, 3);
-        // });
-    });
-});

package/build/data/Grouper.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/data/Grouper.spec.js

@@ -1,48 +0,0 @@
-import { Grouper } from "./Grouper";
-import assert from "assert";
-describe("Grouper", function () {
-    describe("single grouping", function () {
-        it("should work", function () {
-            let data = [
-                { name: "John", age: 12 },
-                { name: "Jane", age: 12 },
-            ];
-            let grouper = new Grouper({ name: { bind: "name" } });
-            grouper.processAll(data);
-            let results = grouper.getResults();
-            // console.log(results);
-            assert.equal(results.length, 2);
-        });
-        it("keys can have nested properties", function () {
-            let data = [
-                { name: "John", age: 12 },
-                { name: "Jane", age: 12 },
-            ];
-            let grouper = new Grouper({ "person.name": { bind: "name" } });
-            grouper.processAll(data);
-            let results = grouper.getResults();
-            assert.equal(results.length, 2);
-            assert.equal(results[0].key.person?.name, "John");
-            assert.equal(results[1].key.person?.name, "Jane");
-        });
-    });
-    describe("multi grouping", function () {
-        it("should work", function () {
-            let data = [
-                { name: "John", age: 12 },
-                { name: "John", age: 12 },
-                { name: "John", age: 13 },
-                { name: "John", age: 14 },
-                { name: "Jane", age: 12 },
-                { name: "Jane", age: 13 },
-                { name: "Jane", age: 14 },
-            ];
-            let grouper = new Grouper({ name: { bind: "name" }, age: { bind: "age" } });
-            grouper.processAll(data);
-            let results = grouper.getResults();
-            // console.log(results);
-            assert.equal(results.length, 6);
-            assert.equal(results[0].records.length, 2);
-        });
-    });
-});

package/build/data/Ref.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/build/data/Ref.spec.js

@@ -1,72 +0,0 @@
-//@ts-nocheck
-import assert from "assert";
-import { Store } from "./Store";
-import { Ref } from "./Ref";
-import { append } from "./ops/append";
-import { StoreRef } from "./StoreRef";
-const getStore = () => {
-    return new Store({
-        data: {
-            a: 3,
-            item: {
-                firstName: "Jack",
-            },
-            array: [],
-        },
-    });
-};
-describe("Ref", () => {
-    it("can init data", () => {
-        let store = getStore();
-        let b = store.ref("b", 1);
-        assert.equal(store.get("b"), 1);
-    });
-    it("can set data", () => {
-        let store = getStore();
-        let b = store.ref("b", 1);
-        b.set(2);
-        assert.equal(store.get("b"), 2);
-    });
-    it("can delete data", () => {
-        let store = getStore();
-        let b = store.ref("item");
-        b.delete();
-        assert.equal(store.get("item"), undefined);
-    });
-    it("can cast itself to a ref of another type", () => {
-        class ArrayRef extends StoreRef {
-            append(...args) {
-                this.update(append, ...args);
-            }
-        }
-        let store = getStore();
-        let array = store.ref("array").as(ArrayRef);
-        array.append(1, 2, 3);
-        assert.deepEqual(array.get(), [1, 2, 3]);
-    });
-    it("can extend itself in a functional way", () => {
-        let store = getStore();
-        let array = store.ref("array").as(({ update, set, path }) => ({
-            append(...args) {
-                update(path, append, ...args);
-            },
-            clear() {
-                set(path, []);
-            },
-        }));
-        array.append(1, 2, 3);
-        assert.deepEqual(array.get(), [1, 2, 3]);
-        array.clear();
-        assert.deepEqual(array.get(), []);
-    });
-    it("can get subrefs", () => {
-        let store = getStore();
-        let person = new Ref({
-            get: () => store.get("person"),
-            set: (value) => store.set("person", value),
-        });
-        let name = person.ref("name");
-        name.set("John");
-        assert.equal(name.get(), "John");
-    });
-});

package/build/data/Store.spec.d.ts

@@ -1 +0,0 @@
-export {};