Skip to content

Commit ec6ebe1

Browse files
bgandobgando
committed
3.3.4
1 parent de5a662 commit ec6ebe1

File tree

5 files changed

+10115
-0
lines changed

5 files changed

+10115
-0
lines changed

‎dist/amd/can-view-scope.js

+279
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,279 @@
1+
/*[email protected]#can-view-scope*/
2+
define([
3+
'require',
4+
'exports',
5+
'module',
6+
'can-stache-key',
7+
'can-observation',
8+
'./reference-map',
9+
'./compute_data',
10+
'can-util/js/assign',
11+
'can-util/js/each',
12+
'can-namespace',
13+
'can-util/js/dev',
14+
'can-reflect',
15+
'can-util/js/log'
16+
], function (require, exports, module) {
17+
var observeReader = require('can-stache-key');
18+
var Observation = require('can-observation');
19+
var ReferenceMap = require('./reference-map');
20+
var makeComputeData = require('./compute_data');
21+
var assign = require('can-util/js/assign');
22+
var each = require('can-util/js/each');
23+
var namespace = require('can-namespace');
24+
var dev = require('can-util/js/dev');
25+
var canReflect = require('can-reflect');
26+
var canLog = require('can-util/js/log');
27+
function Scope(context, parent, meta) {
28+
this._context = context;
29+
this._parent = parent;
30+
this._meta = meta || {};
31+
this.__cache = {};
32+
}
33+
assign(Scope, {
34+
read: observeReader.read,
35+
Refs: ReferenceMap,
36+
refsScope: function () {
37+
return new Scope(new this.Refs());
38+
},
39+
keyInfo: function (attr) {
40+
var info = {};
41+
info.isDotSlash = attr.substr(0, 2) === './';
42+
info.isThisDot = attr.substr(0, 5) === 'this.';
43+
info.isInCurrentContext = info.isDotSlash || info.isThisDot;
44+
info.isInParentContext = attr.substr(0, 3) === '../';
45+
info.isCurrentContext = attr === '.' || attr === 'this';
46+
info.isParentContext = attr === '..';
47+
info.isContextBased = info.isInCurrentContext || info.isInParentContext || info.isCurrentContext || info.isParentContext;
48+
return info;
49+
}
50+
});
51+
assign(Scope.prototype, {
52+
add: function (context, meta) {
53+
if (context !== this._context) {
54+
return new this.constructor(context, this, meta);
55+
} else {
56+
return this;
57+
}
58+
},
59+
read: function (attr, options) {
60+
if (attr === '%root') {
61+
return { value: this.getRoot() };
62+
}
63+
if (attr === '%scope') {
64+
return { value: this };
65+
}
66+
var keyInfo = Scope.keyInfo(attr);
67+
if (keyInfo.isContextBased && this._meta.notContext) {
68+
return this._parent.read(attr, options);
69+
}
70+
var currentScopeOnly;
71+
if (keyInfo.isInCurrentContext) {
72+
currentScopeOnly = true;
73+
attr = keyInfo.isDotSlash ? attr.substr(2) : attr.substr(5);
74+
} else if (keyInfo.isInParentContext || keyInfo.isParentContext) {
75+
var parent = this._parent;
76+
while (parent._meta.notContext) {
77+
parent = parent._parent;
78+
}
79+
if (keyInfo.isParentContext) {
80+
return observeReader.read(parent._context, [], options);
81+
}
82+
return parent.read(attr.substr(3) || '.', options);
83+
} else if (keyInfo.isCurrentContext) {
84+
return observeReader.read(this._context, [], options);
85+
}
86+
var keyReads = observeReader.reads(attr);
87+
if (keyReads[0].key.charAt(0) === '*') {
88+
return this.getRefs()._read(keyReads, options, true);
89+
} else {
90+
return this._read(keyReads, options, currentScopeOnly);
91+
}
92+
},
93+
_read: function (keyReads, options, currentScopeOnly) {
94+
var currentScope = this, currentContext, undefinedObserves = [], currentObserve, currentReads, setObserveDepth = -1, currentSetReads, currentSetObserve, readOptions = assign({
95+
foundObservable: function (observe, nameIndex) {
96+
currentObserve = observe;
97+
currentReads = keyReads.slice(nameIndex);
98+
},
99+
earlyExit: function (parentValue, nameIndex) {
100+
if (nameIndex > setObserveDepth || nameIndex === setObserveDepth && (typeof parentValue === 'object' && keyReads[nameIndex].key in parentValue)) {
101+
currentSetObserve = currentObserve;
102+
currentSetReads = currentReads;
103+
setObserveDepth = nameIndex;
104+
}
105+
}
106+
}, options);
107+
while (currentScope) {
108+
currentContext = currentScope._context;
109+
if (currentContext !== null && (typeof currentContext === 'object' || typeof currentContext === 'function')) {
110+
var getObserves = Observation.trap();
111+
var data = observeReader.read(currentContext, keyReads, readOptions);
112+
var observes = getObserves();
113+
if (data.value !== undefined) {
114+
Observation.addAll(observes);
115+
return {
116+
scope: currentScope,
117+
rootObserve: currentObserve,
118+
value: data.value,
119+
reads: currentReads
120+
};
121+
} else {
122+
undefinedObserves.push.apply(undefinedObserves, observes);
123+
}
124+
}
125+
if (currentScopeOnly) {
126+
currentScope = null;
127+
} else {
128+
currentScope = currentScope._parent;
129+
}
130+
}
131+
Observation.addAll(undefinedObserves);
132+
return {
133+
setRoot: currentSetObserve,
134+
reads: currentSetReads,
135+
value: undefined
136+
};
137+
},
138+
get: function (key, options) {
139+
options = assign({ isArgument: true }, options);
140+
var res = this.read(key, options);
141+
return res.value;
142+
},
143+
peek: Observation.ignore(function (key, options) {
144+
return this.get(key, options);
145+
}),
146+
peak: Observation.ignore(function (key, options) {
147+
return this.peek(key, options);
148+
}),
149+
getScope: function (tester) {
150+
var scope = this;
151+
while (scope) {
152+
if (tester(scope)) {
153+
return scope;
154+
}
155+
scope = scope._parent;
156+
}
157+
},
158+
getContext: function (tester) {
159+
var res = this.getScope(tester);
160+
return res && res._context;
161+
},
162+
getRefs: function () {
163+
var lastScope;
164+
var refScope = this.getScope(function (scope) {
165+
lastScope = scope;
166+
return scope._context instanceof Scope.Refs;
167+
});
168+
if (!refScope) {
169+
lastScope._parent = new Scope.Refs();
170+
refScope = lastScope._parent;
171+
}
172+
return refScope;
173+
},
174+
getRoot: function () {
175+
var cur = this, child = this;
176+
while (cur._parent) {
177+
child = cur;
178+
cur = cur._parent;
179+
}
180+
if (cur._context instanceof Scope.Refs) {
181+
cur = child;
182+
}
183+
return cur._context;
184+
},
185+
set: function (key, value, options) {
186+
options = options || {};
187+
var keyInfo = Scope.keyInfo(key);
188+
if (keyInfo.isCurrentContext) {
189+
return canReflect.setValue(this._context, value);
190+
} else if (keyInfo.isInParentContext || keyInfo.isParentContext) {
191+
var parent = this._parent;
192+
while (parent._meta.notContext) {
193+
parent = parent._parent;
194+
}
195+
if (keyInfo.isParentContext) {
196+
return canReflect.setValue(parent._context, value);
197+
}
198+
return parent.set(key.substr(3) || '.', value, options);
199+
}
200+
var dotIndex = key.lastIndexOf('.'), slashIndex = key.lastIndexOf('/'), contextPath, propName;
201+
if (slashIndex > dotIndex) {
202+
contextPath = key.substring(0, slashIndex);
203+
propName = key.substring(slashIndex + 1, key.length);
204+
} else {
205+
if (dotIndex !== -1) {
206+
contextPath = key.substring(0, dotIndex);
207+
propName = key.substring(dotIndex + 1, key.length);
208+
} else {
209+
contextPath = '.';
210+
propName = key;
211+
}
212+
}
213+
if (key.charAt(0) === '*') {
214+
observeReader.write(this.getRefs()._context, key, value, options);
215+
} else {
216+
var context = this.read(contextPath, options).value;
217+
if (!canReflect.isObservableLike(context) && canReflect.isObservableLike(context[propName])) {
218+
if (canReflect.isMapLike(context[propName])) {
219+
dev.warn('can-view-scope: Merging data into "' + propName + '" because its parent is non-observable');
220+
canReflect.updateDeep(context[propName], value);
221+
} else if (canReflect.isValueLike(context[propName])) {
222+
canReflect.setValue(context[propName], value);
223+
} else {
224+
observeReader.write(context, propName, value, options);
225+
}
226+
} else {
227+
observeReader.write(context, propName, value, options);
228+
}
229+
}
230+
},
231+
attr: Observation.ignore(function (key, value, options) {
232+
canLog.warn('can-view-scope::attr is deprecated, please use peek, get or set');
233+
options = assign({ isArgument: true }, options);
234+
if (arguments.length === 2) {
235+
return this.set(key, value, options);
236+
} else {
237+
return this.get(key, options);
238+
}
239+
}),
240+
computeData: function (key, options) {
241+
return makeComputeData(this, key, options);
242+
},
243+
compute: function (key, options) {
244+
return this.computeData(key, options).compute;
245+
},
246+
cloneFromRef: function () {
247+
var contexts = [];
248+
var scope = this, context, parent;
249+
while (scope) {
250+
context = scope._context;
251+
if (context instanceof Scope.Refs) {
252+
parent = scope._parent;
253+
break;
254+
}
255+
contexts.unshift(context);
256+
scope = scope._parent;
257+
}
258+
if (parent) {
259+
each(contexts, function (context) {
260+
parent = parent.add(context);
261+
});
262+
return parent;
263+
} else {
264+
return this;
265+
}
266+
}
267+
});
268+
function Options(data, parent, meta) {
269+
if (!data.helpers && !data.partials && !data.tags) {
270+
data = { helpers: data };
271+
}
272+
Scope.call(this, data, parent, meta);
273+
}
274+
Options.prototype = new Scope();
275+
Options.prototype.constructor = Options;
276+
Scope.Options = Options;
277+
namespace.view = namespace.view || {};
278+
module.exports = namespace.view.Scope = Scope;
279+
});

0 commit comments

Comments
 (0)