Socket
Socket
Sign inDemoInstall

realar

Package Overview
Dependencies
Maintainers
1
Versions
129
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

realar - npm Package Compare versions

Comparing version 0.6.0-alpha.2 to 0.6.0-alpha.3

12

build/index.d.ts

@@ -40,3 +40,3 @@ import React, { FC } from 'react';

};
view: {
map: {
<R>(func: (value: O) => R): Value<I, R>;

@@ -98,5 +98,5 @@ untrack<R>(func: (value: O) => R): Value<I, R>;

};
view: {
map: {
<R>(func: (value: O) => R): Signal<I, R>;
untrack<R>(func: (value: O) => R): Signal<I, R>;
track<R>(func: (value: O) => R): Signal<I, R>;
};

@@ -118,9 +118,9 @@ flow: any;

<N>(func?: (value: N) => I): Signal<N, O>;
untrack<N>(func?: (value: N) => I): Signal<N, O>;
track<N>(func?: (value: N) => I): Signal<N, O>;
filter: {
(func?: (value: O) => any): Signal<I, O>;
untrack(func?: (value: O) => any): Signal<I, O>;
track(func?: (value: O) => any): Signal<I, O>;
not: {
(func?: (value: O) => any): Signal<I, O>;
untrack(func?: (value: O) => any): Signal<I, O>;
track(func?: (value: O) => any): Signal<I, O>;
};

@@ -127,0 +127,0 @@ };

49

build/index.js

@@ -94,3 +94,3 @@ "use strict";

const key_select = 'select';
const key_view = 'view';
const key_map = 'map';
const key_handler = new_symbol();

@@ -178,2 +178,3 @@ const key_pre = 'pre';

};
const obj_empty_from = (cfg) => obj_is_array(cfg) ? [] : {};
const fill_entity = (handler, proto, has_initial, initial, _get, _set) => {

@@ -229,5 +230,2 @@ let set = _set || handler[1];

};
const make_updater = (ctx, fn, is_value) => (is_value = (is_value ? value : signal)(),
trait_ent_update_by(ctx, is_value, fn),
is_value);
const make_trait_ent_pure_fn_untrack = (trait_fn) => (ctx, fn) => trait_fn(ctx, fn && ((a, b) => {

@@ -251,3 +249,3 @@ const finish = internal_untrack();

}));
const op_trait_if_signal = (trait_if_not_signal, trait_if_signal) => ((ctx) => ctx[key_handler][key_is_signal] ? trait_if_signal : trait_if_not_signal);
const op_trait_if_not_signal = (trait_if_not_signal, trait_if_signal) => ((ctx) => ctx[key_handler][key_is_signal] ? trait_if_signal : trait_if_not_signal);
const make_proto_for_trackable_ns = (trait_track, trait_untrack) => (obj_def_prop_trait_ns(obj_def_prop_trait_ns(obj_create(pure_fn), key_track, trait_track), key_untrack, trait_untrack));

@@ -273,4 +271,8 @@ const prop_factory_dirty_required_initial = (ctx) => {

ctx);
const trait_ent_updater = (ctx, fn) => make_updater(ctx, fn);
const trait_ent_updater_value = (ctx, fn) => make_updater(ctx, fn, 1);
const trait_ent_updater = (ctx, fn) => {
const sig = signal();
trait_ent_update_by(ctx, sig, fn);
return sig;
};
const trait_ent_updater_multiple = (ctx, cfg) => obj_keys(cfg).reduce((ret, key) => ((ret[key] = trait_ent_updater(ctx, cfg[key])), ret), obj_empty_from(cfg));
const trait_ent_sync = (ctx, fn) => (reactionable_subscribe(ctx, fn, 0, 1), ctx);

@@ -298,6 +300,6 @@ const trait_ent_reset = (ctx) => {

const trait_ent_select_untrack = make_trait_ent_pure_fn_untrack(trait_ent_select);
const trait_ent_select_multiple = (ctx, cfg) => obj_keys(cfg).reduce((ret, key) => ((ret[key] = trait_ent_select(ctx, cfg[key])), ret), obj_is_array(cfg) ? [] : {});
const trait_ent_select_multiple_untrack = (ctx, cfg) => obj_keys(cfg).reduce((ret, key) => ((ret[key] = trait_ent_select_untrack(ctx, cfg[key])), ret), obj_is_array(cfg) ? [] : {});
const trait_ent_view = (ctx, fn) => (fill_entity(ctx[key_handler], ctx[key_proto], 0, 0, fn ? () => fn(ctx[key_get]()) : ctx[key_get], ctx[key_set] && ctx[key_set].bind()));
const trait_ent_view_untrack = make_trait_ent_pure_fn_untrack(trait_ent_view);
const trait_ent_select_multiple = (ctx, cfg) => obj_keys(cfg).reduce((ret, key) => ((ret[key] = trait_ent_select(ctx, cfg[key])), ret), obj_empty_from(cfg));
const trait_ent_select_multiple_untrack = (ctx, cfg) => obj_keys(cfg).reduce((ret, key) => ((ret[key] = trait_ent_select_untrack(ctx, cfg[key])), ret), obj_empty_from(cfg));
const trait_ent_map = (ctx, fn) => (fill_entity(ctx[key_handler], ctx[key_proto], 0, 0, fn ? () => fn(ctx[key_get]()) : ctx[key_get], ctx[key_set] && ctx[key_set].bind()));
const trait_ent_map_untrack = make_trait_ent_pure_fn_untrack(trait_ent_map);
const trait_ent_pre = (ctx, fn) => (fn

@@ -358,3 +360,3 @@ ? fill_entity(ctx[key_handler], ctx[key_proto], 0, 0, ctx[key_get], (v) => ctx[key_set](fn(v)))

const proto_entity_readable_filter_ns = obj_create(make_proto_for_trackable_ns(trait_ent_filter, trait_ent_filter_untrack));
obj_def_prop_trait_ns_with_ns(proto_entity_readable_filter_ns, key_not, op_trait_if_signal(trait_ent_filter_not, trait_ent_filter_not_untrack), make_proto_for_trackable_ns(trait_ent_filter_not, trait_ent_filter_not_untrack), 1);
obj_def_prop_trait_ns_with_ns(proto_entity_readable_filter_ns, key_not, op_trait_if_not_signal(trait_ent_filter_not, trait_ent_filter_not_untrack), make_proto_for_trackable_ns(trait_ent_filter_not, trait_ent_filter_not_untrack), 1);
// readable.select:ns (track|untrack)

@@ -378,3 +380,3 @@ // .select.multiple (track|untrack)

// .flow (track|untrack)
// .view (track|untrack)
// .map (track|untrack)
// .join (track|untrack)

@@ -388,6 +390,6 @@ // .as:readable.as:ns

obj_def_prop_trait_with_ns(proto_entity_readable, key_to, trait_ent_to, proto_entity_readable_to_ns);
obj_def_prop_trait_with_ns(proto_entity_readable, key_filter, op_trait_if_signal(trait_ent_filter, trait_ent_filter_untrack), proto_entity_readable_filter_ns, 1);
obj_def_prop_trait_with_ns(proto_entity_readable, key_flow, op_trait_if_signal(trait_ent_flow, trait_ent_flow_untrack), make_proto_for_trackable_ns(trait_ent_flow, trait_ent_flow_untrack), 1);
obj_def_prop_trait_with_ns(proto_entity_readable, key_filter, op_trait_if_not_signal(trait_ent_filter, trait_ent_filter_untrack), proto_entity_readable_filter_ns, 1);
obj_def_prop_trait_with_ns(proto_entity_readable, key_flow, op_trait_if_not_signal(trait_ent_flow, trait_ent_flow_untrack), make_proto_for_trackable_ns(trait_ent_flow, trait_ent_flow_untrack), 1);
obj_def_prop_trait_with_ns(proto_entity_readable, key_select, trait_ent_select, proto_entity_readable_select_ns);
obj_def_prop_trait_with_ns(proto_entity_readable, key_view, trait_ent_view, make_proto_for_trackable_ns(trait_ent_view, trait_ent_view_untrack));
obj_def_prop_trait_with_ns(proto_entity_readable, key_map, op_trait_if_not_signal(trait_ent_map, trait_ent_map_untrack), make_proto_for_trackable_ns(trait_ent_map, trait_ent_map_untrack), 1);
obj_def_prop_trait_with_ns(proto_entity_readable, key_join, trait_ent_join, make_proto_for_trackable_ns(trait_ent_join, trait_ent_join_untrack));

@@ -405,13 +407,13 @@ obj_def_prop_with_ns(proto_entity_readable, key_as, proto_entity_readable_as_ns);

// writtable.updater:ns
// .updater.value
// .updater.multiple
const proto_entity_writtable_updater_ns = obj_create(pure_fn);
obj_def_prop_trait_ns(proto_entity_writtable_updater_ns, key_value, trait_ent_updater_value);
obj_def_prop_trait_ns(proto_entity_writtable_updater_ns, key_multiple, trait_ent_updater_multiple);
// writtable.pre.filter:ns (track|untrack)
// .pre.filter.not (track|untrack)
const proto_entity_writtable_pre_filter_ns = obj_create(make_proto_for_trackable_ns(trait_ent_pre_filter, trait_ent_pre_filter_untrack));
obj_def_prop_trait_ns_with_ns(proto_entity_writtable_pre_filter_ns, key_not, trait_ent_pre_filter_not, make_proto_for_trackable_ns(trait_ent_pre_filter_not, trait_ent_pre_filter_not_untrack));
obj_def_prop_trait_ns_with_ns(proto_entity_writtable_pre_filter_ns, key_not, op_trait_if_not_signal(trait_ent_pre_filter_not, trait_ent_pre_filter_not_untrack), make_proto_for_trackable_ns(trait_ent_pre_filter_not, trait_ent_pre_filter_not_untrack), 1);
// writtable.pre:ns (track|untrack)
// .pre.filter:writtable.pre.filter:ns (track|untrack)
const proto_entity_writtable_pre_ns = obj_create(make_proto_for_trackable_ns(trait_ent_pre, trait_ent_pre_untrack));
obj_def_prop_trait_ns_with_ns(proto_entity_writtable_pre_ns, key_filter, trait_ent_pre_filter, proto_entity_writtable_pre_filter_ns);
obj_def_prop_trait_ns_with_ns(proto_entity_writtable_pre_ns, key_filter, op_trait_if_not_signal(trait_ent_pre_filter, trait_ent_pre_filter_untrack), proto_entity_writtable_pre_filter_ns, 1);
// writtable <- readable

@@ -421,3 +423,3 @@ // .update:writtable.update:ns (track|untrack)

// .updater:writtable.updater:ns
// .updater.value
// .updater.miltiple
// .pre:writtable.pre:ns (track|untrack)

@@ -429,3 +431,3 @@ // .pre.filter:writtable.pre.filter:ns (track|untrack)

obj_def_prop_trait_with_ns(proto_entity_writtable, key_updater, trait_ent_updater, proto_entity_writtable_updater_ns);
obj_def_prop_trait_with_ns(proto_entity_writtable, key_pre, trait_ent_pre, proto_entity_writtable_pre_ns);
obj_def_prop_trait_with_ns(proto_entity_writtable, key_pre, op_trait_if_not_signal(trait_ent_pre, trait_ent_pre_untrack), proto_entity_writtable_pre_ns, 1);
// writtable_leaf.reset.by:ns

@@ -472,5 +474,4 @@ // .reset.by.once

: (key) => sel(get_getter_to_reactionable_or_custom(cfg[key]))[0]);
const is_array = obj_is_array(cfg);
const h = [
() => keys.reduce((ret, key, key_index) => ((ret[key] = fns[key_index]()), ret), is_array ? [] : {})
() => keys.reduce((ret, key, key_index) => ((ret[key] = fns[key_index]()), ret), obj_empty_from(cfg))
];

@@ -477,0 +478,0 @@ h[key_is_signal] = is_signal;

4

package.json
{
"name": "realar",
"version": "0.6.0-alpha.2",
"version": "0.6.0-alpha.3",
"description": "The advanced state manager less than 5kB for React",

@@ -88,3 +88,3 @@ "repository": {

},
"gitHead": "41de6de61105d191282ff40c2ebc685c4f558df1"
"gitHead": "c229617c48645a799e5e69457e469f2a2e38c822"
}

207

README.md

@@ -5,3 +5,3 @@ # Realar

State manager to reduce developers' coding time and increase the lifetime of your codebase.
The state manager to reduce developers' coding time and increase the lifetime of your codebase.

@@ -26,124 +26,62 @@ Realar targeted to all scale applications up to complex enterprise solutions on modular architecture.

The start piece of code with basic operations of reactive value and signals
```javascript
import { value } from 'realar'
import React from 'react';
import { value, signal, useValue, useLocal, useShared, shared } from 'realar';
// Realar's adventure will start from "value",
// is an immutable reactive container such as
// "store" from Redux terminology
const store = value(0)
const counterLogic = () => {
const count = value(0)
const inc = count.updater(state => state + 1)
const add = count.updater((state, num) => state + num)
// You can easily make functional update
// signals similar to an "action" from Redux
const inc = store.updater(state => state + 1)
const add = store.updater((state, num: number) => state + num)
return { count, inc, add }
}
// Watch updating
store.to((state) => console.log(state))
const formLogic = () => {
const { add } = shared(counterLogic)
// And run signals as usual functions
inc() // console output: 1
add(10) // console output: 11
```
[Try on RunKit](https://runkit.com/betula/60b4e0cab769ca0021660348)
const addendum = value('0').pre(ev => ev.target.value)
const sum = signal()
.map(() => +addendum.val)
.filter()
.to(add);
return { addendum, sum }
}
### Signals
The `signal` allows you to trigger an event or action and delivers the functionality to subscribe to it anywhere in your application code.
Usually, signal subscription (_by `on` function_) very comfortable coding in class constructors.
```javascript
const startAnimation = signal();
class Animation {
constructor() {
on(startAnimation, this.start);
}
start = async () => {
console.log('animation starting...');
}
const Form = () => {
const { addendum, sum } = useLocal(formLogic)
const addendumState = useValue(addendum)
return (
<p>
<input value={addendumState} onChange={addendum} />
<button onClick={sum}>sum</button>
</p>
)
}
shared(Animation);
startAnimation();
```
[Edit on RunKit](https://runkit.com/betula/602f62db23b6cd001adc5dfa)
If you making an instance of a class with a subscription in the constructor, though `shared`, `useLocal`, `useScoped` Realar functions, It will be unsubscribed automatically.
Below other examples
```javascript
const add = signal<number>();
const store = value(1);
on(add, num => store.val += num);
add(15);
console.log(store.val); // console output: 16
```
[Edit on RunKit](https://runkit.com/betula/6013af7649e8720019c9cf2a)
An signal is convenient to use as a promise.
```javascript
const fire = signal();
(async () => {
for (;;) {
await fire.promise; // await as a usual promise
console.log('Fire');
}
})();
setInterval(fire, 500);
```
[Edit on RunKit](https://runkit.com/betula/601e3b0056b62d001bfa391b)
### Core
The abstraction of the core is an implementation of functional reactive programming on javascript and binding that with React.
It uses usual mathematic to describe dependencies and commutation between reactive values.
In contradistinction to _stream pattern_, operator functions not needed. The reactive “sum” operator used a simple “+” operator (for example).
```javascript
const a = value(0)
const b = value(0)
const sum = () => a.val + b.val
on(sum, console.log)
```
That code has a graph of dependencies inside. “sum” - reactive expression depends from “A” and “B”, and will react if “A” or “B” changed. It is perfectly demonstrated with “on” function (that subscribes to reactive expression) and “console.log” (developer console output).
On each change of “A” or “B” a new value of that sum will appear in the developer console output.
And for tasty easy binding reactive expressions and values with React components.
```javascript
const App = () => {
const val = useValue(sum);
const Counter = () => {
const { count, inc } = useShared(counterLogic)
const countState = useValue(count)
return (
<p>{val}</p>
);
<p>
{countState}
<button onClick={inc}>inc</button>
</p>
)
}
```
That component will be updated every time when new sum value is coming.
const App = () => (
<>
<Counter />
<Form />
<Counter />
<Form />
</>
)
The difference from exists an implementation of functional reactive programming (mobx) in Realar dependency collector provides the possibility to write in selectors and nested writable reactions.
```
[Try on CodeSandbox](https://codesandbox.io/s/realar-basic-example-41vvd?file=/src/App.tsx)
Realar provides big possibility abstractions for reactive flow. We already know about reactive value container, reactive expressions, and subscribe mechanism. But also have synchronization between data, cycled reactions, cached selectors, transactions and etc.
### OOP Usage

@@ -277,14 +215,55 @@

### Core
The abstraction of the core is an implementation of functional reactive programming on javascript and binding that with React.
### API
It uses usual mathematic to describe dependencies and commutation between reactive values.
- [value](./docs/api.md)
- [selector](./docs/api.md)
- [on](./docs/api.md)
- [cache](./docs/api.md)
- [cycle](./docs/api.md)
- [sync](./docs/api.md)
In contradistinction to _stream pattern_, operator functions not needed. The reactive “sum” operator used a simple “+” operator (for example).
```javascript
const a = value(0)
const b = value(0)
const sum = () => a.val + b.val
on(sum, console.log)
```
That code has a graph of dependencies inside. “sum” - reactive expression depends from “A” and “B”, and will react if “A” or “B” changed. It is perfectly demonstrated with “on” function (that subscribes to reactive expression) and “console.log” (developer console output).
On each change of “A” or “B” a new value of that sum will appear in the developer console output.
And for tasty easy binding reactive expressions and values with React components.
```javascript
const App = () => {
const val = useValue(sum);
return (
<p>{val}</p>
);
}
```
That component will be updated every time when new sum value is coming.
The difference from exists an implementation of functional reactive programming (mobx) in Realar dependency collector provides the possibility to write in selectors and nested writable reactions.
Realar provides big possibility abstractions for reactive flow. We already know about reactive value container, reactive expressions, and subscribe mechanism. But also have synchronization between data, cycled reactions, cached selectors, transactions and etc.
### Documentation
- [Get started](./docs/get-started.md)
- API
- [value](./docs/api.md)
- [signal](./docs/api.md)
- [selector](./docs/api.md)
- [on](./docs/api.md)
- [cache](./docs/api.md)
- [cycle](./docs/api.md)
- [sync](./docs/api.md)
### Demos

@@ -291,0 +270,0 @@

98

src/index.ts
import React, { Context, FC } from 'react';
import rb from 'reactive-box';
/*

@@ -8,6 +12,3 @@ TODOs:

[] Add store.updater.multiple
[] Complete the draft explanation of the introductory section
[] Add second example to documentation

@@ -37,3 +38,2 @@

Backlog:
[] Try terser for result code size optimization
[] .as.trigger

@@ -166,3 +166,3 @@ [] .as.value.trigger

}
view: {
map: {
<R>(func: (value: O) => R): Value<I, R> // tracked by default

@@ -235,5 +235,5 @@ untrack<R>(func: (value: O) => R): Value<I, R>

}
view: {
<R>(func: (value: O) => R): Signal<I, R> // tracked by default
untrack<R>(func: (value: O) => R): Signal<I, R>
map: {
<R>(func: (value: O) => R): Signal<I, R> // untracked by default
track<R>(func: (value: O) => R): Signal<I, R>
}

@@ -258,10 +258,10 @@

pre: {
<N>(func?: (value: N) => I): Signal<N, O> // tracked by default
untrack<N>(func?: (value: N) => I): Signal<N, O>
<N>(func?: (value: N) => I): Signal<N, O> // untracked by default
track<N>(func?: (value: N) => I): Signal<N, O>
filter: {
(func?: (value: O) => any): Signal<I, O> // tracked by default
untrack(func?: (value: O) => any): Signal<I, O>
not: { // tracked by default
(func?: (value: O) => any): Signal<I, O> // untracked by default
track(func?: (value: O) => any): Signal<I, O>
not: { // untracked by default
(func?: (value: O) => any): Signal<I, O>
untrack(func?: (value: O) => any): Signal<I, O>
track(func?: (value: O) => any): Signal<I, O>
}

@@ -542,3 +542,3 @@ }

const key_select = 'select';
const key_view = 'view';
const key_map = 'map';
const key_handler = new_symbol();

@@ -646,3 +646,5 @@ const key_pre = 'pre';

const obj_empty_from = (cfg) => obj_is_array(cfg) ? [] : {};
const fill_entity = (handler, proto, has_initial?, initial?, _get?, _set?) => {

@@ -697,8 +699,4 @@ let set = _set || handler[1];

const make_updater = (ctx, fn, is_value?) => (
is_value = ((is_value ? value : signal) as any)(),
trait_ent_update_by(ctx, is_value, fn),
is_value
)
const make_trait_ent_pure_fn_untrack = (trait_fn) =>

@@ -718,3 +716,3 @@ (ctx, fn) => trait_fn(ctx, fn && ((a,b) => {

const op_trait_if_signal = (trait_if_not_signal, trait_if_signal) => (
const op_trait_if_not_signal = (trait_if_not_signal, trait_if_signal) => (
(ctx) => ctx[key_handler][key_is_signal] ? trait_if_signal : trait_if_not_signal

@@ -761,4 +759,10 @@ );

);
const trait_ent_updater = (ctx, fn) => make_updater(ctx, fn);
const trait_ent_updater_value = (ctx, fn) => make_updater(ctx, fn, 1);
const trait_ent_updater = (ctx, fn) => {
const sig = signal();
trait_ent_update_by(ctx, sig, fn);
return sig;
}
const trait_ent_updater_multiple = (ctx, cfg) => obj_keys(cfg).reduce((ret, key) => (
(ret[key] = trait_ent_updater(ctx, cfg[key])), ret
), obj_empty_from(cfg));
const trait_ent_sync = (ctx, fn) => (reactionable_subscribe(ctx, fn, 0, 1), ctx);

@@ -798,7 +802,7 @@ const trait_ent_reset = (ctx) => {

(ret[key] = trait_ent_select(ctx, cfg[key])), ret
), obj_is_array(cfg) ? [] : {});
), obj_empty_from(cfg));
const trait_ent_select_multiple_untrack = (ctx, cfg) => obj_keys(cfg).reduce((ret, key) => (
(ret[key] = trait_ent_select_untrack(ctx, cfg[key])), ret
), obj_is_array(cfg) ? [] : {});
const trait_ent_view = (ctx, fn) => (
), obj_empty_from(cfg));
const trait_ent_map = (ctx, fn) => (
fill_entity(ctx[key_handler], ctx[key_proto],

@@ -810,3 +814,3 @@ 0, 0,

);
const trait_ent_view_untrack = make_trait_ent_pure_fn_untrack(trait_ent_view);
const trait_ent_map_untrack = make_trait_ent_pure_fn_untrack(trait_ent_map);
const trait_ent_pre = (ctx, fn) => (

@@ -906,3 +910,3 @@ fn

obj_def_prop_trait_ns_with_ns(proto_entity_readable_filter_ns, key_not,
op_trait_if_signal(trait_ent_filter_not, trait_ent_filter_not_untrack),
op_trait_if_not_signal(trait_ent_filter_not, trait_ent_filter_not_untrack),
make_proto_for_trackable_ns(trait_ent_filter_not, trait_ent_filter_not_untrack),

@@ -936,3 +940,3 @@ 1

// .flow (track|untrack)
// .view (track|untrack)
// .map (track|untrack)
// .join (track|untrack)

@@ -954,3 +958,3 @@ // .as:readable.as:ns

key_filter,
op_trait_if_signal(trait_ent_filter, trait_ent_filter_untrack),
op_trait_if_not_signal(trait_ent_filter, trait_ent_filter_untrack),
proto_entity_readable_filter_ns,

@@ -962,3 +966,3 @@ 1

key_flow,
op_trait_if_signal(trait_ent_flow, trait_ent_flow_untrack),
op_trait_if_not_signal(trait_ent_flow, trait_ent_flow_untrack),
make_proto_for_trackable_ns(trait_ent_flow, trait_ent_flow_untrack),

@@ -975,5 +979,6 @@ 1

proto_entity_readable,
key_view,
trait_ent_view,
make_proto_for_trackable_ns(trait_ent_view, trait_ent_view_untrack),
key_map,
op_trait_if_not_signal(trait_ent_map, trait_ent_map_untrack),
make_proto_for_trackable_ns(trait_ent_map, trait_ent_map_untrack),
1
);

@@ -1008,5 +1013,5 @@ obj_def_prop_trait_with_ns(

// writtable.updater:ns
// .updater.value
// .updater.multiple
const proto_entity_writtable_updater_ns = obj_create(pure_fn);
obj_def_prop_trait_ns(proto_entity_writtable_updater_ns, key_value, trait_ent_updater_value);
obj_def_prop_trait_ns(proto_entity_writtable_updater_ns, key_multiple, trait_ent_updater_multiple);

@@ -1018,4 +1023,6 @@ // writtable.pre.filter:ns (track|untrack)

);
obj_def_prop_trait_ns_with_ns(proto_entity_writtable_pre_filter_ns, key_not, trait_ent_pre_filter_not,
make_proto_for_trackable_ns(trait_ent_pre_filter_not, trait_ent_pre_filter_not_untrack)
obj_def_prop_trait_ns_with_ns(proto_entity_writtable_pre_filter_ns, key_not,
op_trait_if_not_signal(trait_ent_pre_filter_not, trait_ent_pre_filter_not_untrack),
make_proto_for_trackable_ns(trait_ent_pre_filter_not, trait_ent_pre_filter_not_untrack),
1
);

@@ -1031,4 +1038,5 @@

key_filter,
trait_ent_pre_filter,
proto_entity_writtable_pre_filter_ns
op_trait_if_not_signal(trait_ent_pre_filter, trait_ent_pre_filter_untrack),
proto_entity_writtable_pre_filter_ns,
1
);

@@ -1040,3 +1048,3 @@

// .updater:writtable.updater:ns
// .updater.value
// .updater.miltiple
// .pre:writtable.pre:ns (track|untrack)

@@ -1061,4 +1069,5 @@ // .pre.filter:writtable.pre.filter:ns (track|untrack)

key_pre,
trait_ent_pre,
proto_entity_writtable_pre_ns
op_trait_if_not_signal(trait_ent_pre, trait_ent_pre_untrack),
proto_entity_writtable_pre_ns,
1
);

@@ -1138,7 +1147,6 @@

);
const is_array = obj_is_array(cfg);
const h = [
() => keys.reduce((ret, key, key_index) => (
(ret[key] = fns[key_index]()), ret
), is_array ? [] : {})
), obj_empty_from(cfg))
];

@@ -1145,0 +1153,0 @@ h[key_is_signal] = is_signal;

build/index.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc