LibAcc: 0.6590=143/217, ProjAcc: 0.7069=41/58, Missing: 550
Module: src/util/primitive
function 𝓟232{isScalar} (𝓟233{value}: [OOV]any): (𝓟234: 𝓛[ty]8666{Boolean})
{
return 𝓟234 = 𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟233{value},𝓛12643{undefined}),𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟233{value}),𝓛8743{String}))
}
function 𝓟235{isObject} (𝓟236{value}: [OOV]any): (𝓟237: 𝓛[ty]8666{Boolean})
{
return 𝓟237 = 𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟236{value},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟236{value}),𝓛8743{String})),𝓛12569{ExclamationToken}(𝓛8757{Array}.isArray(𝓟236{value})))
}
function 𝓟238{isObjectOrNull} (𝓟239{value}: [OOV]any): (𝓟240: 𝓛[ty]8666{Boolean})
{
return 𝓟240 = 𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟239{value}),𝓛8743{String}),𝓛12569{ExclamationToken}(𝓛8757{Array}.isArray(𝓟239{value})))
}
function 𝓟241{isNil} (𝓟242{value}: [OOV]any): (𝓟243: 𝓛[ty]8666{Boolean})
{
return 𝓟243 = 𝓛12546{BarBarToken}(𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟242{value},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟242{value},𝓛12643{undefined})),𝓛8745{Number}.isNaN(𝓟242{value}))
}
function 𝓟244{isNumber} (𝓟245{element}: [OOV]any): (𝓟246: 𝓛[ty]8666{Boolean})
{
return 𝓟246 = 𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟245{element}),𝓛8743{String}),𝓛12569{ExclamationToken}(𝓛8745{Number}.isNaN(𝓟245{element})))
}
Module: src/operations/extract
function 𝓟247{extract} (𝓟248{graphSnapshot}: 𝓟[ty]1387{GraphSnapshot},𝓟249{cacheContext}: 𝓟[ty]406{CacheContext}): (𝓟250: [OOV]𝓟[ty]793{GraphSnapshot})
{
const 𝓟251{result}: [OOV]𝓟[ty]793{GraphSnapshot} = {};
const 𝓟252{entities}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟248{graphSnapshot}._values;
{
const 𝓟253{id}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟252{entities});
while (𝓛8744{Boolean})
{
const 𝓟254{nodeSnapshot}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟252{entities}.access(𝓟253{id});
const 𝓟255{outbound}: [miss]𝓛[ty]8670{Array} = 𝓟254{nodeSnapshot}.outbound;
const 𝓟256{inbound}: [miss]𝓛[ty]8670{Array} = 𝓟254{nodeSnapshot}.inbound;
let 𝓟257{type}: 𝓛[ty]8655{Number};
if (𝓛1{<UNKNOWN>}(𝓟254{nodeSnapshot},𝓛12643{undefined}))
{
𝓟257{type} ⟵ 𝓟796{NodeSnapshotType}.EntitySnapshot;
}
else
{
if (𝓛1{<UNKNOWN>}(𝓟254{nodeSnapshot},𝓛12643{undefined}))
{
𝓟257{type} ⟵ 𝓟796{NodeSnapshotType}.ParameterizedValueSnapshot;
}
else
{
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓟254{nodeSnapshot}.constructor.name))
}
}
const 𝓟258{serializedEntity}: [OOV]𝓟[ty]794{NodeSnapshot} = {type: 𝓟257{type}};
if (𝓟255{outbound})
{
𝓟258{serializedEntity}.outbound ⟵ 𝓟255{outbound};
}
if (𝓟256{inbound})
{
𝓟258{serializedEntity}.inbound ⟵ 𝓟256{inbound};
}
const 𝓟259{extractedData}: [OOV]𝓟[ty]513{NestedValue} = 𝓟260{extractSerializableData}(𝓟248{graphSnapshot},𝓟254{nodeSnapshot});
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟259{extractedData},𝓛12643{undefined}))
{
if (𝓟249{cacheContext}.tracer.warning)
{
{
if (𝓛12569{ExclamationToken}(𝓟797{isSerializable}(𝓟259{extractedData},𝓛8744{Boolean})))
{
𝓟249{cacheContext}.tracer.warning(𝓛12607{$Template}(𝓟253{id}))
}
}
}
𝓟258{serializedEntity}.data ⟵ 𝓟259{extractedData};
}
𝓟251{result}.access(𝓟253{id}) ⟵ 𝓟258{serializedEntity};
}
}
return 𝓟250 = 𝓟251{result}
}
function 𝓟260{extractSerializableData} (𝓟261{graphSnapshot}: 𝓟[ty]1387{GraphSnapshot},𝓟262{nodeSnapshot}: [OOV]𝓟[ty]1314{NodeSnapshot}): (𝓟263: [OOV]𝓟[ty]513{NestedValue})
{
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟262{nodeSnapshot}.outbound),𝓛12569{ExclamationToken}(𝓟262{nodeSnapshot}.data)))
{
return 𝓟263 = 𝓟262{nodeSnapshot}.data
}
let 𝓟264{extractedData}: [OOV]any = 𝓟262{nodeSnapshot}.data;
{
const 𝓟265{outbound}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛12589{$ArrayAccess}(𝓟262{nodeSnapshot}.outbound);
while (𝓛8744{Boolean})
{
if (𝓛1{<UNKNOWN>}(𝓟261{graphSnapshot}.getNodeSnapshot(𝓟265{outbound}.id),𝓛12643{undefined}))
{
𝓟264{extractedData} ⟵ 𝓟465{lazyImmutableDeepSet}(𝓟264{extractedData},𝓟262{nodeSnapshot}.data,𝓟265{outbound}.path,(𝓛12559{EqualsEqualsEqualsToken}(𝓟265{outbound}.path.length,𝓛8745{Number}) ? 𝓛12643{undefined} : 𝓛12643{undefined});
}
}
}
return 𝓟263 = 𝓟264{extractedData}
}
Module: src/errors
function 𝓟266{CONSTRUCTOR} (): (𝓟[ty]270{CacheError})
{
const 𝓟[ty]270{CacheError};
const 𝓟[ty]270{CacheError};
}
class 𝓟[ty]270{CacheError} extends 𝓛[ty]2{<UNKNOWN>}{
}
function 𝓟272{CONSTRUCTOR} (𝓟273{message}: 𝓛[ty]10051{String},𝓟274{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟[ty]278{QueryError})
{
const 𝓟[ty]278{QueryError};
const 𝓟[ty]278{QueryError};
𝓟[ty]278{QueryError}.path ⟵ 𝓟274{path};
𝓟[ty]278{QueryError}(𝓛12607{$Template}(𝓟273{message},𝓟334{prettyPath}(𝓟274{path})))
}
class 𝓟[ty]278{QueryError} extends 𝓟[ty]270{CacheError}{
𝓟280{path}: 𝓛[ty]8670{Array};
}
function 𝓟281{CONSTRUCTOR} (): (𝓟[ty]285{UnsatisfiedCacheError})
{
const 𝓟[ty]285{UnsatisfiedCacheError};
const 𝓟[ty]285{UnsatisfiedCacheError};
}
class 𝓟[ty]285{UnsatisfiedCacheError} extends 𝓟[ty]270{CacheError}{
}
function 𝓟287{CONSTRUCTOR} (𝓟288{message}: 𝓛[ty]10051{String},𝓟289{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟290{fields}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array})): (𝓟[ty]294{ConflictingFieldsError})
{
const 𝓟[ty]294{ConflictingFieldsError};
const 𝓟[ty]294{ConflictingFieldsError};
𝓟[ty]294{ConflictingFieldsError}.fields ⟵ 𝓟290{fields};
𝓟[ty]294{ConflictingFieldsError}.path ⟵ 𝓟289{path};
𝓟[ty]294{ConflictingFieldsError}(𝓛12607{$Template}(𝓟288{message}),𝓟289{path})
}
class 𝓟[ty]294{ConflictingFieldsError} extends 𝓟[ty]278{QueryError}{
𝓟296{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
𝓟297{fields}: 𝓛[ty]8670{Array};
}
function 𝓟298{CONSTRUCTOR} (𝓟299{message}: 𝓛[ty]10051{String},𝓟300{prefixPath}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟301{nodeId}: 𝓛[ty]10051{String},𝓟302{path}: 𝓛[ty]8670{Array},𝓟303{value}: [OOV]any): (𝓟[ty]307{OperationError})
{
const 𝓟[ty]307{OperationError};
const 𝓟[ty]307{OperationError};
𝓟[ty]307{OperationError}.nodeId ⟵ 𝓟301{nodeId};
𝓟[ty]307{OperationError}.prefixPath ⟵ 𝓟300{prefixPath};
𝓟[ty]307{OperationError}.value ⟵ 𝓟303{value};
𝓟[ty]307{OperationError}.path ⟵ 𝓟302{path};
𝓟[ty]307{OperationError}(𝓛12607{$Template}(𝓟299{message},𝓟334{prettyPath}(𝓛8757{Array}(𝓛12587{$Spread}(𝓟300{prefixPath}),𝓛12587{$Spread}(𝓟302{path}))),𝓟301{nodeId}))
}
class 𝓟[ty]307{OperationError} extends 𝓟[ty]270{CacheError}{
𝓟309{prefixPath}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
𝓟310{nodeId}: 𝓛[ty]10051{String};
𝓟311{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
𝓟312{value}: [OOV]any;
}
function 𝓟313{CONSTRUCTOR} (): (𝓟[ty]317{InvalidPayloadError})
{
const 𝓟[ty]317{InvalidPayloadError};
const 𝓟[ty]317{InvalidPayloadError};
}
class 𝓟[ty]317{InvalidPayloadError} extends 𝓟[ty]307{OperationError}{
}
function 𝓟319{CONSTRUCTOR} (𝓟320{message}: 𝓛[ty]10051{String},𝓟321{prefixPath}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟322{nodeId}: (𝓟[ty]344{EntitySnapshot} ≠ 𝓛[ty]10051{String}),𝓟323{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟324{value}: [OOV]any): (𝓟[ty]328{CacheConsistencyError})
{
const 𝓟[ty]328{CacheConsistencyError};
const 𝓟[ty]328{CacheConsistencyError};
𝓟[ty]328{CacheConsistencyError}.nodeId ⟵ 𝓟322{nodeId};
𝓟[ty]328{CacheConsistencyError}.prefixPath ⟵ 𝓟321{prefixPath};
𝓟[ty]328{CacheConsistencyError}.value ⟵ 𝓟324{value};
𝓟[ty]328{CacheConsistencyError}.path ⟵ 𝓟323{path};
𝓟[ty]328{CacheConsistencyError}(𝓛12607{$Template}(𝓟320{message}),𝓟321{prefixPath},𝓟322{nodeId},𝓟323{path})
}
class 𝓟[ty]328{CacheConsistencyError} extends 𝓟[ty]307{OperationError}{
𝓟330{prefixPath}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
𝓟331{nodeId}: 𝓛[ty]10051{String};
𝓟332{path}: 𝓛[ty]8670{Array};
𝓟333{value}: [OOV]any;
}
function 𝓟334{prettyPath} (𝓟335{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟336: [miss]𝓛[ty]10051{String})
{
return 𝓟336 = (𝓛1{<UNKNOWN>} ? 𝓛2363{join}(𝓛8743{String}) : 𝓛8743{String}
}
Module: src/index
Module: src/util/references
type 𝓟[ty]349{ReferenceDirection} = any
function 𝓟350{removeNodeReference} (𝓟351{direction}: [OOV]𝓟[ty]349{ReferenceDirection},𝓟352{snapshot}: [OOV]𝓟[ty]1314{NodeSnapshot},𝓟353{id}: 𝓛[ty]10051{String},𝓟354{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟355: 𝓛[ty]8666{Boolean})
{
const 𝓟356{references}: [miss]𝓛[ty]8670{Array} = 𝓟352{snapshot}.access(𝓟351{direction});
if (𝓛12569{ExclamationToken}(𝓟356{references}))
{
return 𝓟355 = 𝓛8744{Boolean}
}
const 𝓟357{fromIndex}: [miss]𝓛[ty]8655{Number} = 𝓟373{getIndexOfGivenReference}(𝓟356{references},𝓟353{id},𝓟354{path});
if (𝓛1{<UNKNOWN>}(𝓟357{fromIndex},𝓛8745{Number}))
{
return 𝓟355 = 𝓛8744{Boolean}
}
𝓟356{references}.splice(𝓟357{fromIndex},𝓛8745{Number})
if (𝓛12569{ExclamationToken}(𝓟356{references}.length))
{
𝓟352{snapshot}.access(𝓟351{direction}) ⟵ 𝓛12643{undefined};
}
return 𝓟355 = 𝓛12569{ExclamationToken}(𝓟356{references}.length)
}
function 𝓟358{addNodeReference} (𝓟359{direction}: [OOV]𝓟[ty]349{ReferenceDirection},𝓟360{snapshot}: [OOV]𝓟[ty]1314{NodeSnapshot},𝓟361{id}: 𝓛[ty]10051{String},𝓟362{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟363: 𝓛[ty]8666{Boolean})
{
let 𝓟364{references}: [miss]𝓛[ty]8670{Array} = 𝓟360{snapshot}.access(𝓟359{direction});
if (𝓛12569{ExclamationToken}(𝓟364{references}))
{
𝓟364{references} ⟵ 𝓛1{<UNKNOWN>}(𝓟360{snapshot}.access(𝓟359{direction}),𝓛8757{Array}());
}
const 𝓟365{idx}: [miss]𝓛[ty]8655{Number} = 𝓟373{getIndexOfGivenReference}(𝓟364{references},𝓟361{id},𝓟362{path});
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟365{idx},𝓛12616{MinusToken}(𝓛8745{Number})))
{
𝓟364{references}.push({id: 𝓟361{id},path: 𝓟362{path}})
return 𝓟363 = 𝓛8744{Boolean}
}
return 𝓟363 = 𝓛8744{Boolean}
}
function 𝓟366{hasNodeReference} (𝓟367{snapshot}: [OOV]𝓟[ty]1314{NodeSnapshot},𝓟368{type}: [OOV]𝓟[ty]349{ReferenceDirection},𝓟369{id}: 𝓛[ty]10051{String},𝓟370{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟371: 𝓛[ty]8666{Boolean})
{
const 𝓟372{references}: [miss]𝓛[ty]8670{Array} = 𝓟367{snapshot}.access(𝓟368{type});
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟372{references}),𝓛12559{EqualsEqualsEqualsToken}(𝓟373{getIndexOfGivenReference}(𝓟372{references},𝓟369{id},𝓟370{path}),𝓛12616{MinusToken}(𝓛8745{Number}))))
{
return 𝓟371 = 𝓛8744{Boolean}
}
return 𝓟371 = 𝓛8744{Boolean}
}
function 𝓟373{getIndexOfGivenReference} (𝓟374{references}: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓛[ty]8670{Array}),𝓟375{id}: 𝓛[ty]10051{String},𝓟376{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟377: 𝓛[ty]8655{Number})
{
function 𝓟378{$Lambda14} (𝓟379{reference}): (𝓟380: [OOV]any)
{
return 𝓟380 = 𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟379{reference}.id,𝓟375{id}),𝓟1513{isEqual}(𝓟379{reference}.path,𝓟376{path}))
}
return 𝓟377 = 𝓟374{references}.findIndex(𝓟378{$Lambda14})
}
function 𝓟381{isReferenceField} (𝓟382{snapshot}: [OOV]𝓟[ty]1314{NodeSnapshot},𝓟383{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟384: 𝓛[ty]8666{Boolean})
{
const 𝓟385{references}: [miss]𝓛[ty]8670{Array} = 𝓟382{snapshot}.access(𝓛8743{String});
if (𝓛12569{ExclamationToken}(𝓟385{references}))
{
return 𝓟384 = 𝓛8744{Boolean}
}
function 𝓟386{$Lambda15} (𝓟387{reference}): (𝓟388: [OOV]any)
{
return 𝓟388 = 𝓟1513{isEqual}(𝓟387{reference}.path,𝓟383{path})
}
const 𝓟389{index}: [miss]𝓛[ty]8655{Number} = 𝓟385{references}.findIndex(𝓟386{$Lambda15});
return 𝓟384 = 𝓛12596{GreaterThanEqualsToken}(𝓟389{index},𝓛8745{Number})
}
Module: src/context/CacheContext
type 𝓟[ty]390{DocumentNode} = {hasBeenTransformed: 𝓛[ty]8666{Boolean}}
type 𝓟[ty]391{EntityUpdaters} = {access: (𝓛[ty]10051{String})->𝓟[ty]395{EntityUpdater}}
type 𝓟[ty]392{EntityIdForValue} = (any)->any
type 𝓟[ty]393{OnChangeCallback} = (𝓟[ty]811{CacheSnapshot},𝓛[ty]5956{Set})->𝓛[ty]10033{Void}
type 𝓟[ty]394{ResolverRedirects} = {access: (𝓛[ty]10051{String})->{access: (𝓛[ty]10051{String})->𝓟[ty]396{ResolverRedirect}}}
type 𝓟[ty]395{EntityUpdater} = {call: (𝓟[ty]1352{ApolloTransaction},any,any)->𝓛[ty]10033{Void}}
type 𝓟[ty]396{ResolverRedirect} = (𝓟[ty]506{NestedObject})->any
type 𝓟[ty]397{EntityIdMapper} = (𝓟[ty]506{NestedObject})->any
type 𝓟[ty]398{EntityTransformer} = (𝓟[ty]506{NestedObject})->𝓛[ty]10033{Void}
type 𝓟[ty]399{Configuration} = {resolverRedirects: 𝓟[ty]394{ResolverRedirects}, logger: 𝓟[ty]1301{Logger}, verbose: 𝓛[ty]8666{Boolean}, onChange: 𝓟[ty]393{OnChangeCallback}, freeze: 𝓛[ty]8666{Boolean}, entityTransformer: 𝓟[ty]398{EntityTransformer}, addTypename: 𝓛[ty]8666{Boolean}, tracer: 𝓟[ty]816{Tracer}, entityUpdaters: 𝓟[ty]391{EntityUpdaters}, entityIdForNode: 𝓟[ty]397{EntityIdMapper}}
type 𝓟[ty]400{EntityIdForNode} = (𝓟[ty]506{NestedObject})->any
function 𝓟401{CONSTRUCTOR} (𝓟402{config}: [OOV]𝓟[ty]399{Configuration}): (𝓟[ty]406{CacheContext})
{
const 𝓟[ty]406{CacheContext};
const 𝓟[ty]406{CacheContext};
𝓟[ty]406{CacheContext}._operationMap ⟵ 𝓛2995{Map}.CONSTRUCTOR();
𝓟[ty]406{CacheContext}._queryInfoMap ⟵ 𝓛2995{Map}.CONSTRUCTOR();
𝓟[ty]406{CacheContext}.entityIdForValue ⟵ 𝓟437{_makeEntityIdMapper}(𝓟402{config}.entityIdForNode);
𝓟[ty]406{CacheContext}.entityTransformer ⟵ 𝓟402{config}.entityTransformer;
𝓟[ty]406{CacheContext}.freezeSnapshots ⟵ (𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟402{config}) ? 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟402{config}.freeze)) : 𝓛12612{ExclamationEqualsEqualsToken}(𝓟1515{lodashGet}(𝓛10055{global},𝓛8743{String}),𝓛8743{String});
𝓟[ty]406{CacheContext}.verbose ⟵ 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟402{config}.verbose));
𝓟[ty]406{CacheContext}.resolverRedirects ⟵ 𝓛12546{BarBarToken}(𝓟402{config}.resolverRedirects,{});
𝓟[ty]406{CacheContext}.onChange ⟵ 𝓟402{config}.onChange;
𝓟[ty]406{CacheContext}.entityUpdaters ⟵ 𝓛12546{BarBarToken}(𝓟402{config}.entityUpdaters,{});
𝓟[ty]406{CacheContext}.tracer ⟵ 𝓛12546{BarBarToken}(𝓟402{config}.tracer,𝓟1247{CONSTRUCTOR}(𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟402{config}.verbose)),𝓟402{config}.logger));
𝓟[ty]406{CacheContext}._addTypename ⟵ 𝓛12546{BarBarToken}(𝓟402{config}.addTypename,𝓛8744{Boolean});
}
class 𝓟[ty]406{CacheContext}{
𝓟408{entityIdForValue}: [OOV]𝓟[ty]392{EntityIdForValue};
𝓟409{freezeSnapshots}: 𝓛[ty]8666{Boolean};
𝓟410{resolverRedirects}: [OOV]𝓟[ty]394{ResolverRedirects};
𝓟411{verbose}: 𝓛[ty]8666{Boolean};
𝓟412{onChange}: [OOV]any;
𝓟413{_queryInfoMap}: [miss]𝓛[ty]3199{Map};
𝓟414{entityTransformer}: [OOV]any;
𝓟415{tracer}: [OOV]𝓟[ty]816{Tracer};
𝓟416{entityUpdaters}: [OOV]𝓟[ty]391{EntityUpdaters};
𝓟417{_operationMap}: [miss]𝓛[ty]3199{Map};
𝓟418{_addTypename}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean});
function 𝓟419{transformDocument} (𝓟420{document}: [OOV]𝓛[ty]22936{DocumentNode}): (𝓟421: [OOV]𝓛[ty]22936{DocumentNode})
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟[ty]406{CacheContext}._addTypename,𝓛12569{ExclamationToken}(𝓟420{document}.hasBeenTransformed)))
{
const 𝓟422{transformedDocument} = 𝓟1514{addTypenameToDocument}(𝓟420{document});
𝓟422{transformedDocument}.hasBeenTransform ⟵ 𝓛8744{Boolean};
return 𝓟421 = 𝓟422{transformedDocument}
}
return 𝓟421 = 𝓟420{document}
}
function 𝓟423{parseOperation} (𝓟424{raw}: [OOV]𝓟[ty]787{RawOperation}): (𝓟425: [OOV]𝓟[ty]791{OperationInstance})
{
const 𝓟426{cacheKey} = 𝓟447{operationCacheKey}(𝓟424{raw}.document,𝓟424{raw}.fragmentName);
let 𝓟427{operationInstances}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]406{CacheContext}._operationMap.get(𝓟426{cacheKey});
if (𝓛12569{ExclamationToken}(𝓟427{operationInstances}))
{
𝓟427{operationInstances} ⟵ 𝓛8757{Array}();
𝓟[ty]406{CacheContext}._operationMap.set(𝓟426{cacheKey},𝓟427{operationInstances})
}
{
const 𝓟428{instance}: [OOV]𝓟[ty]791{OperationInstance} = 𝓛12589{$ArrayAccess}(𝓟427{operationInstances});
while (𝓛8744{Boolean})
{
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟428{instance}.rootId,𝓟424{raw}.rootId))
{
}
if (𝓛12569{ExclamationToken}(𝓟1513{isEqual}(𝓟428{instance}.variables,𝓟424{raw}.variables)))
{
}
return 𝓟425 = 𝓟428{instance}
}
}
const 𝓟429{updateRaw}: [OOV]𝓟[ty]787{RawOperation} = {document: 𝓟[ty]406{CacheContext}.transformDocument(𝓟424{raw}.document)};
const 𝓟430{info}: [miss]𝓟[ty]1217{QueryInfo} = 𝓟[ty]406{CacheContext}._queryInfo(𝓟426{cacheKey},𝓟429{updateRaw});
const 𝓟431{fullVariables}: [OOV]𝓛[ty]2{<UNKNOWN>} = {} as 𝓟[ty]506{NestedObject};
const 𝓟432{operation}: [miss]𝓛[ty]8642{Object} = {parsedQuery: 𝓟1158{expandVariables}(𝓟430{info}.parsed,𝓟431{fullVariables}),variables: 𝓟429{updateRaw}.variables,info: 𝓟430{info},rootId: 𝓟429{updateRaw}.rootId,isStatic: 𝓛12569{ExclamationToken}(𝓟1124{areChildrenDynamic}(𝓟430{info}.parsed))};
𝓟427{operationInstances}.push(𝓟432{operation})
return 𝓟425 = 𝓟432{operation}
}
function 𝓟433{_queryInfo} (𝓟434{cacheKey}: 𝓛[ty]10051{String},𝓟435{raw}: [OOV]𝓟[ty]787{RawOperation}): (𝓟436: (𝓟[ty]1253{ConsoleTracer} ≠ 𝓟[ty]1217{QueryInfo}))
{
if (𝓛12569{ExclamationToken}(𝓟[ty]406{CacheContext}._queryInfoMap.has(𝓟434{cacheKey})))
{
𝓟[ty]406{CacheContext}._queryInfoMap.set(𝓟434{cacheKey},𝓟1209{CONSTRUCTOR}(𝓟[ty]406{CacheContext},𝓟435{raw}))
}
return 𝓟436 = 𝓟[ty]406{CacheContext}._queryInfoMap.get(𝓟434{cacheKey})
}
}
function 𝓟437{_makeEntityIdMapper} (𝓟438{mapper}: [OOV]𝓟[ty]397{EntityIdMapper}): (𝓟439: [OOV]𝓟[ty]392{EntityIdForValue})
{
function 𝓟440{entityIdForNode} (𝓟441{node}: [OOV]𝓟[ty]506{NestedObject}): (𝓟442: [miss]𝓛[ty]10051{String})
{
if (𝓛12569{ExclamationToken}(𝓟235{isObject}(𝓟441{node})))
{
return 𝓟442 = 𝓛12643{undefined}
}
const 𝓟443{entityId} = 𝓟438{mapper}(𝓟441{node});
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟443{entityId}),𝓛8743{String}))
{
return 𝓟442 = 𝓟443{entityId}
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟443{entityId}),𝓛8743{String}))
{
return 𝓟442 = 𝓛8743{String}(𝓟443{entityId})
}
return 𝓟442 = 𝓛12643{undefined}
}
return 𝓟439 = 𝓟440{entityIdForNode}
}
function 𝓟444{defaultEntityIdMapper} (𝓟445{node}: (𝓟[ty]1022{OverlayWalkNode} ≠ 𝓛[ty]8642{Object})): (𝓟446: [OOV]any)
{
return 𝓟446 = 𝓟445{node}.id
}
function 𝓟447{operationCacheKey} (𝓟448{document}: [OOV]𝓛[ty]22936{DocumentNode},𝓟449{fragmentName}: 𝓛[ty]10051{String}): (𝓟450: [OOV]any)
{
if (𝓟449{fragmentName})
{
return 𝓟450 = 𝓛12607{$Template}(𝓟449{fragmentName},𝓟448{document}.loc.source.body)
}
return 𝓟450 = 𝓟448{document}.loc.source.body
}
Module: src/util/collection
function 𝓟451{deepGet} (𝓟452{target}: [OOV]any,𝓟453{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟454: [OOV]any)
{
return 𝓟454 = (𝓛1{<UNKNOWN>} ? 𝓟1515{lodashGet}(𝓟452{target},𝓟453{path}) : 𝓟452{target}
}
function 𝓟455{pathBeginsWith} (𝓟456{target}: 𝓛[ty]8670{Array},𝓟457{prefix}: 𝓛[ty]8670{Array}): (𝓟458: [miss]𝓛[ty]8666{Boolean})
{
if (𝓛1{<UNKNOWN>}(𝓟456{target}.length,𝓟457{prefix}.length))
{
return 𝓟458 = 𝓛8744{Boolean}
}
{
let 𝓟459{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟459{i},𝓟457{prefix}.length))
{
{
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟457{prefix}.access(𝓟459{i}),𝓟456{target}.access(𝓟459{i})))
{
return 𝓟458 = 𝓛8744{Boolean}
}
}
𝓛12556{POST_PlusPlusToken}(𝓟459{i})
}
}
return 𝓟458 = 𝓛8744{Boolean}
}
function 𝓟460{addToSet} (𝓟461{target}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]5956{Set}),𝓟462{source}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]5968{Iterable})): (𝓟463: 𝓛[ty]10033{Void})
{
{
const 𝓟464{value}: [OOV]any = 𝓛12589{$ArrayAccess}(𝓟462{source});
while (𝓛8744{Boolean})
{
𝓟461{target}.add(𝓟464{value})
}
}
}
function 𝓟465{lazyImmutableDeepSet} (𝓟466{target}: [OOV]any,𝓟467{original}: [OOV]any,𝓟468{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟469{value}: [OOV]any): (𝓟470: [OOV]any)
{
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}))
{
return 𝓟470 = 𝓟469{value}
}
let 𝓟471{parentNode};
let 𝓟472{targetNode}: [OOV]any = 𝓟466{target};
let 𝓟473{originalNode}: [OOV]any = 𝓟467{original};
{
let 𝓟474{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟474{i},𝓛1{<UNKNOWN>}))
{
{
const 𝓟475{key} = 𝓛1{<UNKNOWN>}(𝓟474{i});
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟472{targetNode}),𝓛12559{EqualsEqualsEqualsToken}(𝓟472{targetNode},𝓟473{originalNode})))
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟475{key}),𝓛8743{String}))
{
𝓟472{targetNode} ⟵ (𝓟473{originalNode} ? 𝓛8757{Array}(𝓛12587{$Spread}(𝓟473{originalNode})) : 𝓛8757{Array}();
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟475{key}),𝓛8743{String}))
{
𝓟472{targetNode} ⟵ (𝓟473{originalNode} ? {} : {};
}
else
{
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓛8756{JSON}.stringify(𝓟475{key}),𝓛8756{JSON}.stringify(𝓟468{path}),𝓟474{i}))
}
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟474{i},𝓛8745{Number}))
{
𝓟466{target} ⟵ 𝓟472{targetNode};
}
else
{
𝓟471{parentNode}.access(𝓛1{<UNKNOWN>}(𝓛12616{MinusToken}(𝓟474{i},𝓛8745{Number}))) ⟵ 𝓟472{targetNode};
}
}
𝓟471{parentNode} ⟵ 𝓟472{targetNode};
𝓟472{targetNode} ⟵ 𝓟472{targetNode}.access(𝓟475{key});
𝓟473{originalNode} ⟵ 𝓛12592{AmpersandAmpersandToken}(𝓟473{originalNode},𝓟473{originalNode}.access(𝓟475{key}));
}
𝓛12556{POST_PlusPlusToken}(𝓟474{i})
}
}
𝓟471{parentNode}.access(𝓛1{<UNKNOWN>}(𝓛12616{MinusToken}(𝓛1{<UNKNOWN>},𝓛8745{Number}))) ⟵ 𝓟469{value};
return 𝓟470 = 𝓟466{target} as 𝓛[ty]2{<UNKNOWN>}
}
Module: src/primitive
type 𝓟[ty]501{nil} = any
type 𝓟[ty]506{NestedObject} = 𝓟[ty]506{NestedObject}
type 𝓛[ty]8670{Array} = 𝓛[ty]8670{Array}
type 𝓟[ty]513{NestedValue} = 𝓟[ty]513{NestedValue}
type 𝓟[ty]505{DeepReadonly} = any
type 𝓟[ty]506{NestedObject} = {access: (𝓛[ty]10051{String})->𝓟[ty]513{NestedValue}}
type 𝓟[ty]507{DeepPartial} = any
type 𝓟[ty]508{PathPart} = any
type 𝓟[ty]509{scalar} = any
type 𝓟[ty]503{NestedArray} = 𝓛[ty]8670{Array}
type 𝓟[ty]511{Constructor} = {CONSTRUCTOR: (𝓛[ty]8670{Array})->any, prototype: any}
type 𝓟[ty]512{JsonScalar} = any
type 𝓟[ty]513{NestedValue} = any
Module: src/operations/SnapshotEditor
type 𝓟[ty]514{EditedSnapshot} = {snapshot: 𝓟[ty]1387{GraphSnapshot}, editedNodeIds: 𝓛[ty]5956{Set}, writtenQueries: 𝓛[ty]5956{Set}}
type 𝓟[ty]515{NodeSnapshotMap} = any
type 𝓟[ty]516{ReferenceEdit} = {path: 𝓛[ty]8670{Array}, nextNodeId: any, containerId: 𝓛[ty]10051{String}, noWrite: 𝓛[ty]8666{Boolean}, prevNodeId: any}
function 𝓟517{CONSTRUCTOR} (𝓟518{_context}: 𝓟[ty]406{CacheContext},𝓟519{_parent}: (𝓟[ty]681{CacheTransaction} ≠ 𝓟[ty]1387{GraphSnapshot})): (𝓟[ty]523{SnapshotEditor})
{
const 𝓟[ty]523{SnapshotEditor};
const 𝓟[ty]523{SnapshotEditor};
𝓟[ty]523{SnapshotEditor}._writtenQueries ⟵ 𝓛2997{Set}.CONSTRUCTOR();
𝓟[ty]523{SnapshotEditor}._editedNodeIds ⟵ 𝓛2997{Set}.CONSTRUCTOR();
𝓟[ty]523{SnapshotEditor}._newNodes ⟵ 𝓛8741{Object}.create(𝓛12643{undefined});
𝓟[ty]523{SnapshotEditor}._rebuiltNodeIds ⟵ 𝓛2997{Set}.CONSTRUCTOR();
}
class 𝓟[ty]523{SnapshotEditor}{
𝓟525{_newNodes}: [OOV]𝓟[ty]515{NodeSnapshotMap};
𝓟526{_editedNodeIds}: [miss]𝓛[ty]5956{Set};
𝓟527{_rebuiltNodeIds}: [miss]𝓛[ty]5956{Set};
𝓟528{_writtenQueries}: [miss]𝓛[ty]5956{Set};
function 𝓟597{commit} (): (𝓟598: [OOV]𝓟[ty]514{EditedSnapshot})
{
𝓟[ty]523{SnapshotEditor}._rebuildInboundReferences()
const 𝓟599{snapshot}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟[ty]523{SnapshotEditor}._buildNewSnapshot();
if (𝓟[ty]523{SnapshotEditor}._context.freezeSnapshots)
{
𝓟599{snapshot}.freeze()
}
return 𝓟598 = {snapshot: 𝓟599{snapshot},editedNodeIds: 𝓟[ty]523{SnapshotEditor}._editedNodeIds,writtenQueries: 𝓟[ty]523{SnapshotEditor}._writtenQueries}
}
function 𝓟600{_buildNewSnapshot} (): (𝓟601: [miss]𝓟[ty]1387{GraphSnapshot})
{
const 𝓟602{entityTransformer}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]523{SnapshotEditor}._context.entityTransformer;
const 𝓟603{snapshots}: [miss]𝓛[ty]8642{Object} = {};
{
const 𝓟604{id}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]523{SnapshotEditor}._newNodes);
while (𝓛8744{Boolean})
{
const 𝓟605{newSnapshot}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._newNodes.access(𝓟604{id});
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟605{newSnapshot},𝓛12643{undefined}))
{
𝓛12622{$Delete}(𝓟603{snapshots}.access(𝓟604{id}))
}
else
{
if (𝓟602{entityTransformer})
{
const 𝓟606{data}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]523{SnapshotEditor}._newNodes.access(𝓟604{id}) as 𝓟[ty]344{EntitySnapshot}.data;
if (𝓟606{data})
{
𝓟602{entityTransformer}(𝓟606{data})
}
}
𝓟603{snapshots}.access(𝓟604{id}) ⟵ 𝓟605{newSnapshot};
}
}
}
return 𝓟601 = 𝓟1382{CONSTRUCTOR}(𝓟603{snapshots})
}
function 𝓟575{_removeArrayReferences} (𝓟576{referenceEdits}: 𝓛[ty]8670{Array},𝓟577{containerId}: 𝓛[ty]10051{String},𝓟578{prefix}: 𝓛[ty]8670{Array},𝓟579{afterIndex}: 𝓛[ty]8655{Number}): (𝓟580: [miss]𝓛[ty]10033{Void})
{
const 𝓟581{container}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._getNodeSnapshot(𝓟577{containerId});
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟581{container}),𝓛12569{ExclamationToken}(𝓟581{container}.outbound)))
{
}
{
const 𝓟582{reference}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛12589{$ArrayAccess}(𝓟581{container}.outbound);
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟455{pathBeginsWith}(𝓟582{reference}.path,𝓟578{prefix})))
{
}
const 𝓟583{index} = 𝓟582{reference}.path.access(𝓟578{prefix}.length);
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟583{index}),𝓛8743{String}))
{
}
if (𝓛12582{LessThanEqualsToken}(𝓟583{index},𝓟579{afterIndex}))
{
}
𝓟576{referenceEdits}.push({path: 𝓟582{reference}.path,nextNodeId: 𝓛12643{undefined},containerId: 𝓟577{containerId},noWrite: 𝓛8744{Boolean},prevNodeId: 𝓟582{reference}.id})
}
}
}
function 𝓟614{_removeOrphanedNodes} (𝓟615{nodeIds}: (𝓛[ty]10051{String} ≠ 𝓛[ty]5956{Set})): (𝓟616: [miss]𝓛[ty]10033{Void})
{
const 𝓟617{queue}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}.from(𝓟615{nodeIds});
while (𝓟617{queue}.length)
{
const 𝓟618{nodeId}: [miss]𝓛[ty]10051{String} = 𝓟617{queue}.pop();
const 𝓟619{node}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._getNodeSnapshot(𝓟618{nodeId});
if (𝓛12569{ExclamationToken}(𝓟619{node}))
{
}
𝓟[ty]523{SnapshotEditor}._newNodes.access(𝓟618{nodeId}) ⟵ 𝓛12643{undefined};
𝓟[ty]523{SnapshotEditor}._editedNodeIds.add(𝓟618{nodeId})
if (𝓛12569{ExclamationToken}(𝓟619{node}.outbound))
{
}
{
const 𝓟620{id}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟619{node}.outbound).id;
const 𝓟621{path}: [miss]𝓛[ty]8670{Array} = 𝓛12589{$ArrayAccess}(𝓟619{node}.outbound).path;
while (𝓛8744{Boolean})
{
const 𝓟622{reference}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._ensureNewSnapshot(𝓟620{id});
if (𝓟350{removeNodeReference}(𝓛8743{String},𝓟622{reference},𝓟618{nodeId},𝓟621{path}))
{
𝓟617{queue}.push(𝓟620{id})
}
}
}
}
}
function 𝓟630{_setValue} (𝓟631{id}: 𝓛[ty]10051{String},𝓟632{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟633{newValue}: [OOV]any,𝓟634{isEdit}): (𝓟635: [miss]𝓛[ty]10033{Void})
{
if (𝓟634{isEdit})
{
𝓟[ty]523{SnapshotEditor}._editedNodeIds.add(𝓟631{id})
}
const 𝓟636{parent}: [miss]𝓛[ty]8614{Readonly} = 𝓟[ty]523{SnapshotEditor}._parent.getNodeSnapshot(𝓟631{id});
const 𝓟637{current}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._ensureNewSnapshot(𝓟631{id});
𝓟637{current}.data ⟵ 𝓟465{lazyImmutableDeepSet}(𝓟637{current}.data,𝓛12592{AmpersandAmpersandToken}(𝓟636{parent},𝓟636{parent}.data),𝓟632{path},𝓟633{newValue});
}
function 𝓟623{_getNodeSnapshot} (𝓟624{id}: 𝓛[ty]10051{String}): (𝓟625: [OOV]𝓟[ty]1314{NodeSnapshot})
{
return 𝓟625 = (𝓛1{<UNKNOWN>}(𝓟624{id},𝓟[ty]523{SnapshotEditor}._newNodes) ? 𝓟[ty]523{SnapshotEditor}._newNodes.access(𝓟624{id}) : 𝓟[ty]523{SnapshotEditor}._parent.getNodeSnapshot(𝓟624{id})
}
function 𝓟560{_mergeArraySubgraph} (𝓟561{referenceEdits}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟562{warnings}: 𝓛[ty]8670{Array},𝓟563{containerId}: 𝓛[ty]10051{String},𝓟564{prefixPath}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟565{path}: 𝓛[ty]8670{Array},𝓟566{parsed}: [OOV]𝓟[ty]1073{ParsedQueryNodeMap},𝓟567{payload}: [OOV]any,𝓟568{previousValue}: [OOV]any): (𝓟569: [miss]𝓛[ty]10033{Void})
{
if (𝓟241{isNil}(𝓟567{payload}))
{
𝓟[ty]523{SnapshotEditor}._setValue(𝓟563{containerId},𝓟565{path},𝓛12643{undefined},𝓛8744{Boolean})
}
const 𝓟570{payloadLength}: [miss]𝓛[ty]8655{Number} = (𝓟567{payload} ? 𝓟567{payload}.length : 𝓛8745{Number};
const 𝓟571{previousLength}: [miss]𝓛[ty]8655{Number} = (𝓟568{previousValue} ? 𝓟568{previousValue}.length : 𝓛8745{Number};
if (𝓛12546{BarBarToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟570{payloadLength},𝓟571{previousLength}),𝓛12569{ExclamationToken}(𝓟568{previousValue})))
{
const 𝓟572{newArray}: [miss]𝓛[ty]8670{Array} = (𝓛8757{Array}.isArray(𝓟568{previousValue}) ? 𝓟568{previousValue}.slice(𝓛8745{Number},𝓟570{payloadLength}) : 𝓛8757{Array}.CONSTRUCTOR(𝓟570{payloadLength});
𝓟[ty]523{SnapshotEditor}._setValue(𝓟563{containerId},𝓟565{path},𝓟572{newArray})
if (𝓛1{<UNKNOWN>}(𝓟570{payloadLength},𝓟571{previousLength}))
{
𝓟[ty]523{SnapshotEditor}._removeArrayReferences(𝓟561{referenceEdits},𝓟563{containerId},𝓟565{path},𝓛12616{MinusToken}(𝓟570{payloadLength},𝓛8745{Number}))
}
}
{
let 𝓟573{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟573{i},𝓟567{payload}.length))
{
{
let 𝓟574{childPayload}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟567{payload}.access(𝓟573{i});
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟574{childPayload},𝓛12643{undefined}))
{
𝓟574{childPayload} ⟵ 𝓛12643{undefined};
if (𝓛1{<UNKNOWN>}(𝓟573{i},𝓟567{payload}))
{
𝓟562{warnings}.push(𝓛12607{$Template}(𝓛8757{Array}(𝓛12587{$Spread}(𝓟565{path}),𝓟573{i}).join(𝓛8743{String})))
}
else
{
𝓟562{warnings}.push(𝓛12607{$Template}(𝓛8757{Array}(𝓛12587{$Spread}(𝓟565{path}),𝓟573{i}).join(𝓛8743{String})))
}
}
𝓟[ty]523{SnapshotEditor}._mergeSubgraph(𝓟561{referenceEdits},𝓟562{warnings},𝓟563{containerId},𝓟564{prefixPath},𝓛8757{Array}(𝓛12587{$Spread}(𝓟565{path}),𝓟573{i}),𝓟566{parsed},𝓟574{childPayload})
}
𝓛12556{POST_PlusPlusToken}(𝓟573{i})
}
}
}
function 𝓟626{_getNodeData} (𝓟627{id}: 𝓛[ty]10051{String}): (𝓟628: [OOV]𝓛[ty]2{<UNKNOWN>})
{
const 𝓟629{snapshot}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._getNodeSnapshot(𝓟627{id});
return 𝓟628 = (𝓟629{snapshot} ? 𝓟629{snapshot}.data : 𝓛12643{undefined}
}
function 𝓟537{_mergeSubgraph} (𝓟538{referenceEdits}: 𝓛[ty]8670{Array},𝓟539{warnings}: 𝓛[ty]8670{Array},𝓟540{containerId}: 𝓛[ty]10051{String},𝓟541{prefixPath}: 𝓛[ty]8670{Array},𝓟542{path}: 𝓛[ty]8670{Array},𝓟543{parsed}: [OOV]𝓟[ty]1073{ParsedQueryNodeMap},𝓟544{payload}: [OOV]any): (𝓟545: [miss]𝓛[ty]10033{Void})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟544{payload},𝓛12643{undefined}))
{
𝓟544{payload} ⟵ 𝓛12643{undefined};
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟544{payload}),𝓛8743{String}))
{
const 𝓟546{message}: [miss]𝓛[ty]10051{String} = 𝓛12607{$Template}(𝓛12580{$TypeOf}(𝓟544{payload}));
𝓟313{CONSTRUCTOR}(𝓟546{message},𝓟541{prefixPath},𝓟540{containerId},𝓟542{path},𝓟544{payload})
}
const 𝓟547{previousValue} = 𝓟451{deepGet}(𝓟[ty]523{SnapshotEditor}._getNodeData(𝓟540{containerId}),𝓟542{path});
if (𝓛12546{BarBarToken}(𝓛8757{Array}.isArray(𝓟544{payload}),𝓛8757{Array}.isArray(𝓟547{previousValue})))
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟241{isNil}(𝓟547{previousValue})),𝓛12569{ExclamationToken}(𝓛8757{Array}.isArray(𝓟547{previousValue}))))
{
𝓟313{CONSTRUCTOR}(𝓛8743{String},𝓟541{prefixPath},𝓟540{containerId},𝓟542{path},𝓟544{payload})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟241{isNil}(𝓟544{payload})),𝓛12569{ExclamationToken}(𝓛8757{Array}.isArray(𝓟544{payload}))))
{
𝓟313{CONSTRUCTOR}(𝓛8743{String},𝓟541{prefixPath},𝓟540{containerId},𝓟542{path},𝓟544{payload})
}
𝓟[ty]523{SnapshotEditor}._mergeArraySubgraph(𝓟538{referenceEdits},𝓟539{warnings},𝓟540{containerId},𝓟541{prefixPath},𝓟542{path},𝓟543{parsed},𝓟544{payload},𝓟547{previousValue})
}
const 𝓟548{payloadId}: [miss]𝓛[ty]10051{String} = 𝓟[ty]523{SnapshotEditor}._context.entityIdForValue(𝓟544{payload});
const 𝓟549{previousId}: [miss]𝓛[ty]10051{String} = 𝓟[ty]523{SnapshotEditor}._context.entityIdForValue(𝓟547{previousValue});
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟548{payloadId},𝓟549{previousId}))
{
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟241{isNil}(𝓟544{payload})),𝓛12569{ExclamationToken}(𝓟548{payloadId})))
{
const 𝓟550{message}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
𝓟313{CONSTRUCTOR}(𝓟550{message},𝓟541{prefixPath},𝓟540{containerId},𝓟542{path},𝓟544{payload})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟241{isNil}(𝓟547{previousValue})),𝓛12569{ExclamationToken}(𝓟549{previousId})))
{
const 𝓟551{message}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
𝓟313{CONSTRUCTOR}(𝓟551{message},𝓟541{prefixPath},𝓟540{containerId},𝓟542{path},𝓟544{payload})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟548{payloadId},𝓟241{isNil}(𝓟544{payload})))
{
𝓟298{CONSTRUCTOR}(𝓛8743{String},𝓟541{prefixPath},𝓟540{containerId},𝓟542{path},𝓟544{payload})
}
𝓟538{referenceEdits}.push({containerId: 𝓟540{containerId},path: 𝓟542{path},prevNodeId: 𝓟549{previousId},nextNodeId: 𝓟548{payloadId}})
if (𝓛12569{ExclamationToken}(𝓟548{payloadId}))
{
}
}
else
{
if (𝓟241{isNil}(𝓟544{payload}))
{
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟547{previousValue},𝓛12643{undefined}))
{
𝓟[ty]523{SnapshotEditor}._setValue(𝓟540{containerId},𝓟542{path},𝓛12643{undefined},𝓛8744{Boolean})
}
}
}
if (𝓟548{payloadId})
{
𝓟541{prefixPath} ⟵ 𝓛8757{Array}(𝓛12587{$Spread}(𝓟541{prefixPath}),𝓛12587{$Spread}(𝓟542{path}));
𝓟540{containerId} ⟵ 𝓟548{payloadId};
𝓟542{path} ⟵ 𝓛8757{Array}();
}
{
const 𝓟552{payloadName}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟543{parsed});
while (𝓛8744{Boolean})
{
const 𝓟553{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟543{parsed}.access(𝓟552{payloadName});
const 𝓟554{schemaName}: [miss]𝓛[ty]10051{String} = (𝓟553{node}.schemaName ? 𝓟553{node}.schemaName : 𝓟552{payloadName};
let 𝓟555{fieldValue}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟451{deepGet}(𝓟544{payload},𝓛8757{Array}(𝓟552{payloadName})) as any;
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟555{fieldValue},𝓛12643{undefined}))
{
𝓟555{fieldValue} ⟵ 𝓛12643{undefined};
if (𝓛12592{AmpersandAmpersandToken}(𝓟544{payload},𝓛1{<UNKNOWN>}(𝓟552{payloadName},𝓟544{payload})))
{
𝓟539{warnings}.push(𝓛12607{$Template}(𝓛8757{Array}(𝓛12587{$Spread}(𝓟541{prefixPath}),𝓛12587{$Spread}(𝓟542{path})).join(𝓛8743{String})))
}
}
let 𝓟556{containerIdForField}: [miss]𝓛[ty]10051{String} = 𝓟540{containerId};
let 𝓟557{fieldPrefixPath}: [miss]𝓛[ty]8670{Array} = 𝓟541{prefixPath};
let 𝓟558{fieldPath}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛12587{$Spread}(𝓟542{path}),𝓟554{schemaName});
if (𝓟553{node}.args)
{
𝓟556{containerIdForField} ⟵ 𝓟[ty]523{SnapshotEditor}._ensureParameterizedValueSnapshot(𝓟540{containerId},𝓟558{fieldPath},𝓟553{node}.args);
𝓟557{fieldPrefixPath} ⟵ 𝓛8757{Array}(𝓛12587{$Spread}(𝓟541{prefixPath}),𝓛12587{$Spread}(𝓟558{fieldPath}));
𝓟558{fieldPath} ⟵ 𝓛8757{Array}();
}
const 𝓟559{previousFieldValue} = 𝓟451{deepGet}(𝓟[ty]523{SnapshotEditor}._getNodeData(𝓟556{containerIdForField}),𝓟558{fieldPath});
if (𝓟553{node}.children)
{
𝓟[ty]523{SnapshotEditor}._mergeSubgraph(𝓟538{referenceEdits},𝓟539{warnings},𝓟556{containerIdForField},𝓟557{fieldPrefixPath},𝓟558{fieldPath},𝓟553{node}.children,𝓟555{fieldValue})
}
else
{
if (𝓛12569{ExclamationToken}(𝓟1513{isEqual}(𝓟555{fieldValue},𝓟559{previousFieldValue})))
{
𝓟[ty]523{SnapshotEditor}._setValue(𝓟556{containerIdForField},𝓟558{fieldPath},𝓟555{fieldValue})
}
}
}
}
}
function 𝓟607{_rebuildInboundReferences} (): (𝓟608: [miss]𝓛[ty]10033{Void})
{
const 𝓟609{queue}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}.from(𝓟[ty]523{SnapshotEditor}._editedNodeIds);
𝓟460{addToSet}(𝓟[ty]523{SnapshotEditor}._rebuiltNodeIds,𝓟609{queue})
while (𝓟609{queue}.length)
{
const 𝓟610{nodeId}: [miss]𝓛[ty]10051{String} = 𝓟609{queue}.pop();
const 𝓟611{snapshot}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._getNodeSnapshot(𝓟610{nodeId});
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟611{snapshot},𝓛12643{undefined})))
{
}
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟611{snapshot}),𝓛12569{ExclamationToken}(𝓟611{snapshot}.inbound)))
{
}
{
const 𝓟612{id}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟611{snapshot}.inbound).id;
const 𝓟613{path}: [miss]𝓛[ty]8670{Array} = 𝓛12589{$ArrayAccess}(𝓟611{snapshot}.inbound).path;
while (𝓛8744{Boolean})
{
𝓟[ty]523{SnapshotEditor}._setValue(𝓟612{id},𝓟613{path},𝓟611{snapshot}.data,𝓛8744{Boolean})
if (𝓟[ty]523{SnapshotEditor}._rebuiltNodeIds.has(𝓟612{id}))
{
}
𝓟[ty]523{SnapshotEditor}._rebuiltNodeIds.add(𝓟612{id})
𝓟609{queue}.push(𝓟612{id})
}
}
}
}
function 𝓟638{_ensureNewSnapshot} (𝓟639{id}: 𝓛[ty]10051{String}): (𝓟640: [OOV]𝓟[ty]1314{NodeSnapshot})
{
let 𝓟641{parent};
if (𝓛1{<UNKNOWN>}(𝓟639{id},𝓟[ty]523{SnapshotEditor}._newNodes))
{
return 𝓟640 = 𝓟[ty]523{SnapshotEditor}._newNodes.access(𝓟639{id})
}
else
{
𝓟641{parent} ⟵ 𝓟[ty]523{SnapshotEditor}._parent.getNodeSnapshot(𝓟639{id});
}
const 𝓟642{newSnapshot} = (𝓟641{parent} ? 𝓟1498{cloneNodeSnapshot}(𝓟641{parent}) : 𝓟337{CONSTRUCTOR}();
𝓟[ty]523{SnapshotEditor}._newNodes.access(𝓟639{id}) ⟵ 𝓟642{newSnapshot};
return 𝓟640 = 𝓟642{newSnapshot}
}
function 𝓟584{_mergeReferenceEdits} (𝓟585{referenceEdits}: 𝓛[ty]8670{Array}): (𝓟586: [miss]𝓛[ty]5956{Set})
{
const 𝓟587{orphanedNodeIds}: (𝓛[ty]3199{Map} ≠ 𝓛[ty]5956{Set}) = 𝓛2997{Set}.CONSTRUCTOR();
{
const 𝓟588{containerId}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟585{referenceEdits}).containerId;
const 𝓟589{path}: [miss]𝓛[ty]8670{Array} = 𝓛12589{$ArrayAccess}(𝓟585{referenceEdits}).path;
const 𝓟590{prevNodeId}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟585{referenceEdits}).prevNodeId;
const 𝓟591{nextNodeId}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟585{referenceEdits}).nextNodeId;
const 𝓟592{noWrite}: [miss]𝓛[ty]8666{Boolean} = 𝓛12589{$ArrayAccess}(𝓟585{referenceEdits}).noWrite;
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟592{noWrite}))
{
const 𝓟593{target}: [OOV]𝓛[ty]2{<UNKNOWN>} = (𝓟591{nextNodeId} ? 𝓟[ty]523{SnapshotEditor}._getNodeData(𝓟591{nextNodeId}) : 𝓛12643{undefined};
𝓟[ty]523{SnapshotEditor}._setValue(𝓟588{containerId},𝓟589{path},𝓟593{target})
}
const 𝓟594{container}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._ensureNewSnapshot(𝓟588{containerId});
if (𝓟590{prevNodeId})
{
𝓟350{removeNodeReference}(𝓛8743{String},𝓟594{container},𝓟590{prevNodeId},𝓟589{path})
const 𝓟595{prevTarget}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._ensureNewSnapshot(𝓟590{prevNodeId});
𝓟350{removeNodeReference}(𝓛8743{String},𝓟595{prevTarget},𝓟588{containerId},𝓟589{path})
if (𝓛12569{ExclamationToken}(𝓟595{prevTarget}.inbound))
{
𝓟587{orphanedNodeIds}.add(𝓟590{prevNodeId})
}
}
if (𝓟591{nextNodeId})
{
𝓟358{addNodeReference}(𝓛8743{String},𝓟594{container},𝓟591{nextNodeId},𝓟589{path})
const 𝓟596{nextTarget}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._ensureNewSnapshot(𝓟591{nextNodeId});
𝓟358{addNodeReference}(𝓛8743{String},𝓟596{nextTarget},𝓟588{containerId},𝓟589{path})
𝓟587{orphanedNodeIds}.delete(𝓟591{nextNodeId})
}
}
}
return 𝓟586 = 𝓟587{orphanedNodeIds}
}
function 𝓟643{_ensureParameterizedValueSnapshot} (𝓟644{containerId}: 𝓛[ty]10051{String},𝓟645{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟646{args}: [OOV]𝓟[ty]506{NestedObject}): (𝓟647: [miss]𝓛[ty]10051{String})
{
const 𝓟648{fieldId}: [miss]𝓛[ty]10051{String} = 𝓟651{nodeIdForParameterizedValue}(𝓟644{containerId},𝓟645{path},𝓟646{args});
const 𝓟649{containerSnapshot}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]523{SnapshotEditor}._getNodeSnapshot(𝓟644{containerId});
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟649{containerSnapshot}),𝓛12569{ExclamationToken}(𝓟366{hasNodeReference}(𝓟649{containerSnapshot},𝓛8743{String},𝓟648{fieldId},𝓟645{path}))))
{
const 𝓟650{newSnapshot}: [miss]𝓟[ty]1493{ParameterizedValueSnapshot} = 𝓟1486{CONSTRUCTOR}();
𝓟358{addNodeReference}(𝓛8743{String},𝓟650{newSnapshot},𝓟644{containerId},𝓟645{path})
𝓟[ty]523{SnapshotEditor}._newNodes.access(𝓟648{fieldId}) ⟵ 𝓟650{newSnapshot};
𝓟358{addNodeReference}(𝓛8743{String},𝓟[ty]523{SnapshotEditor}._ensureNewSnapshot(𝓟644{containerId}),𝓟648{fieldId},𝓟645{path})
}
return 𝓟647 = 𝓟648{fieldId}
}
function 𝓟529{mergePayload} (𝓟530{query}: [OOV]𝓟[ty]787{RawOperation},𝓟531{payload}: [OOV]𝓟[ty]506{NestedObject}): (𝓟532: 𝓛[ty]8642{Object})
{
const 𝓟533{parsed}: [OOV]𝓟[ty]791{OperationInstance} = 𝓟[ty]523{SnapshotEditor}._context.parseOperation(𝓟530{query});
const 𝓟534{warnings}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
const 𝓟535{referenceEdits}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
𝓟[ty]523{SnapshotEditor}._mergeSubgraph(𝓟535{referenceEdits},𝓟534{warnings},𝓟533{parsed}.rootId,𝓛8757{Array}(),𝓛8757{Array}(),𝓟533{parsed}.parsedQuery,𝓟531{payload})
const 𝓟536{orphanedNodeIds}: [miss]𝓛[ty]5956{Set} = 𝓟[ty]523{SnapshotEditor}._mergeReferenceEdits(𝓟535{referenceEdits});
𝓟[ty]523{SnapshotEditor}._removeOrphanedNodes(𝓟536{orphanedNodeIds})
𝓟[ty]523{SnapshotEditor}._writtenQueries.add(𝓟533{parsed})
return 𝓟532 = (𝓟534{warnings}.length ? {warnings: 𝓟534{warnings}} : {}
}
}
function 𝓟651{nodeIdForParameterizedValue} (𝓟652{containerId}: 𝓛[ty]10051{String},𝓟653{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟654{args}: [OOV]𝓟[ty]506{NestedObject}): (𝓟655: [miss]𝓛[ty]10051{String})
{
return 𝓟655 = 𝓛12607{$Template}(𝓟652{containerId},𝓛8756{JSON}.stringify(𝓟653{path}),𝓛8756{JSON}.stringify(𝓟654{args}))
}
Module: src/apollo/util
function 𝓟663{buildRawOperationFromQuery} (𝓟664{document}: [OOV]𝓛[ty]22936{DocumentNode},𝓟665{variables}: [OOV]𝓟[ty]506{NestedObject},𝓟666{rootId}: 𝓛[ty]10051{String}): (𝓟667: [OOV]𝓟[ty]787{RawOperation})
{
return 𝓟667 = {rootId: 𝓛12546{BarBarToken}(𝓟666{rootId},𝓟792{StaticNodeId}.QueryRoot),document: 𝓟664{document},variables: 𝓟665{variables}}
}
function 𝓟668{buildRawOperationFromFragment} (𝓟669{fragmentDocument}: [OOV]𝓛[ty]22936{DocumentNode},𝓟670{rootId}: 𝓛[ty]10051{String},𝓟671{variables}: [OOV]𝓟[ty]506{NestedObject},𝓟672{fragmentName}: 𝓛[ty]10051{String}): (𝓟673: [OOV]𝓟[ty]787{RawOperation})
{
return 𝓟673 = {fragmentName: 𝓟672{fragmentName},document: 𝓟1516{getFragmentQueryDocument}(𝓟669{fragmentDocument},𝓟672{fragmentName}),variables: 𝓟671{variables},fromFragmentDocument: 𝓛8744{Boolean},rootId: 𝓟670{rootId}}
}
Module: src/CacheTransaction
function 𝓟674{CONSTRUCTOR} (𝓟675{_context}: 𝓟[ty]406{CacheContext},𝓟676{_snapshot}: (𝓟[ty]406{CacheContext} ≠ 𝓟[ty]811{CacheSnapshot}),𝓟677{_optimisticChangeId}: 𝓛[ty]10051{String}): (𝓟[ty]681{CacheTransaction})
{
const 𝓟[ty]681{CacheTransaction};
const 𝓟[ty]681{CacheTransaction};
𝓟[ty]681{CacheTransaction}._writtenQueries ⟵ 𝓛2997{Set}.CONSTRUCTOR();
𝓟[ty]681{CacheTransaction}._editedNodeIds ⟵ 𝓛2997{Set}.CONSTRUCTOR();
𝓟[ty]681{CacheTransaction}._deltas ⟵ 𝓛8757{Array}();
𝓟[ty]681{CacheTransaction}._parentSnapshot ⟵ 𝓟676{_snapshot};
}
class 𝓟[ty]681{CacheTransaction} extends 𝓟[ty]1380{Queryable}{
𝓟683{_editedNodeIds}: [miss]𝓛[ty]5956{Set};
𝓟684{_deltas}: 𝓛[ty]8670{Array};
𝓟685{_writtenQueries}: [miss]𝓛[ty]5956{Set};
𝓟686{_parentSnapshot}: 𝓟[ty]811{CacheSnapshot};
function 𝓟692{read} (𝓟693{query}: [OOV]𝓟[ty]787{RawOperation}): (𝓟694: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓛[ty]8642{Object}))
{
return 𝓟694 = 𝓟997{read}(𝓟[ty]681{CacheTransaction}._context,𝓟693{query},(𝓟[ty]681{CacheTransaction}._optimisticChangeId ? 𝓟[ty]681{CacheTransaction}._snapshot.optimistic : 𝓟[ty]681{CacheTransaction}._snapshot.baseline)
}
function 𝓟689{transformDocument} (𝓟690{document}: [OOV]𝓛[ty]22936{DocumentNode}): (𝓟691: [OOV]𝓛[ty]22936{DocumentNode})
{
return 𝓟691 = 𝓟[ty]681{CacheTransaction}._context.transformDocument(𝓟690{document})
}
function 𝓟708{commit} (): (𝓟709: 𝓛[ty]8642{Object})
{
𝓟[ty]681{CacheTransaction}._triggerEntityUpdaters()
let 𝓟710{snapshot}: [miss]𝓟[ty]811{CacheSnapshot} = 𝓟[ty]681{CacheTransaction}._snapshot;
if (𝓟[ty]681{CacheTransaction}._optimisticChangeId)
{
𝓟710{snapshot} ⟵ 𝓟804{CONSTRUCTOR}(𝓟710{snapshot}.baseline,𝓟710{snapshot}.optimistic,𝓟710{snapshot}.optimisticQueue.enqueue(𝓟[ty]681{CacheTransaction}._optimisticChangeId,𝓟[ty]681{CacheTransaction}._deltas));
}
return 𝓟709 = {snapshot: 𝓟710{snapshot},editedNodeIds: 𝓟[ty]681{CacheTransaction}._editedNodeIds,writtenQueries: 𝓟[ty]681{CacheTransaction}._writtenQueries}
}
function 𝓟687{isOptimisticTransaction} (): (𝓟688: [OOV]any)
{
return 𝓟688 = (𝓟[ty]681{CacheTransaction}._optimisticChangeId ? 𝓛8744{Boolean} : 𝓛12643{undefined}
}
function 𝓟711{getPreviousNodeSnapshot} (𝓟712{nodeId}: 𝓛[ty]10051{String}): (𝓟713: [OOV]any)
{
const 𝓟714{prevSnapshot}: [miss]𝓟[ty]1387{GraphSnapshot} = (𝓟[ty]681{CacheTransaction}._optimisticChangeId ? 𝓟[ty]681{CacheTransaction}._parentSnapshot.optimistic : 𝓟[ty]681{CacheTransaction}._parentSnapshot.baseline;
return 𝓟713 = 𝓟714{prevSnapshot}.getNodeSnapshot(𝓟712{nodeId})
}
function 𝓟719{_triggerEntityUpdaters} (): (𝓟720: [miss]𝓛[ty]10033{Void})
{
const 𝓟721{entityUpdaters}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]681{CacheTransaction}._context.entityUpdaters;
if (𝓛12569{ExclamationToken}(𝓛8741{Object}.keys(𝓟721{entityUpdaters}).length))
{
}
const 𝓟722{nodesToEmit}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
{
const 𝓟723{nodeId}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]681{CacheTransaction}._editedNodeIds);
while (𝓛8744{Boolean})
{
const 𝓟724{node}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]681{CacheTransaction}.getCurrentNodeSnapshot(𝓟723{nodeId});
const 𝓟725{previous}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓟[ty]681{CacheTransaction}.getPreviousNodeSnapshot(𝓟723{nodeId});
const 𝓟726{either}: [OOV]𝓟[ty]1314{NodeSnapshot} = 𝓛12546{BarBarToken}(𝓟724{node},𝓟725{previous});
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟726{either},𝓛12643{undefined})))
{
}
let 𝓟727{typeName}: [miss]𝓛[ty]10051{String} = 𝓛12592{AmpersandAmpersandToken}(𝓟235{isObject}(𝓟726{either}.data),𝓟726{either}.data.__typename as any);
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟727{typeName}),𝓛12559{EqualsEqualsEqualsToken}(𝓟723{nodeId},𝓟792{StaticNodeId}.QueryRoot)))
{
𝓟727{typeName} ⟵ 𝓛8743{String};
}
if (𝓛12569{ExclamationToken}(𝓟727{typeName}))
{
}
const 𝓟728{updater}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟721{entityUpdaters}.access(𝓟727{typeName});
if (𝓛12569{ExclamationToken}(𝓟728{updater}))
{
}
𝓟722{nodesToEmit}.push({updater: 𝓟728{updater},node: 𝓛12592{AmpersandAmpersandToken}(𝓟724{node},𝓟724{node}.data),previous: 𝓛12592{AmpersandAmpersandToken}(𝓟725{previous},𝓟725{previous}.data)})
}
}
if (𝓛12569{ExclamationToken}(𝓟722{nodesToEmit}.length))
{
}
const 𝓟729{dataProxy}: [miss]𝓟[ty]1352{ApolloTransaction} = 𝓟1347{CONSTRUCTOR}(𝓟[ty]681{CacheTransaction});
{
const 𝓟730{updater} = 𝓛12589{$ArrayAccess}(𝓟722{nodesToEmit}).updater;
const 𝓟731{node} = 𝓛12589{$ArrayAccess}(𝓟722{nodesToEmit}).node;
const 𝓟732{previous} = 𝓛12589{$ArrayAccess}(𝓟722{nodesToEmit}).previous;
while (𝓛8744{Boolean})
{
𝓟730{updater}(𝓟729{dataProxy},𝓟731{node},𝓟732{previous})
}
}
}
function 𝓟742{_buildOptimisticSnapshot} (𝓟743{baseline}: 𝓟[ty]1387{GraphSnapshot}): (𝓟744: [miss]𝓟[ty]1387{GraphSnapshot})
{
const 𝓟745{optimisticQueue}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]681{CacheTransaction}._snapshot.optimisticQueue;
if (𝓛12569{ExclamationToken}(𝓟745{optimisticQueue}.hasUpdates()))
{
return 𝓟744 = 𝓟743{baseline}
}
const 𝓟746{snapshot}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟745{optimisticQueue}.apply(𝓟[ty]681{CacheTransaction}._context,𝓟743{baseline}).snapshot;
const 𝓟747{editedNodeIds}: [miss]𝓛[ty]5956{Set} = 𝓟745{optimisticQueue}.apply(𝓟[ty]681{CacheTransaction}._context,𝓟743{baseline}).editedNodeIds;
𝓟460{addToSet}(𝓟[ty]681{CacheTransaction}._editedNodeIds,𝓟747{editedNodeIds})
return 𝓟744 = 𝓟746{snapshot}
}
function 𝓟715{getCurrentNodeSnapshot} (𝓟716{nodeId}: 𝓛[ty]10051{String}): (𝓟717: [OOV]any)
{
const 𝓟718{currentSnapshot}: [miss]𝓟[ty]1387{GraphSnapshot} = (𝓟[ty]681{CacheTransaction}._optimisticChangeId ? 𝓟[ty]681{CacheTransaction}._snapshot.optimistic : 𝓟[ty]681{CacheTransaction}._snapshot.baseline;
return 𝓟717 = 𝓟718{currentSnapshot}.getNodeSnapshot(𝓟716{nodeId})
}
function 𝓟699{rollback} (𝓟700{changeId}: 𝓛[ty]10051{String}): (𝓟701: 𝓛[ty]10033{Void})
{
const 𝓟702{current}: [miss]𝓟[ty]811{CacheSnapshot} = 𝓟[ty]681{CacheTransaction}._snapshot;
const 𝓟703{optimisticQueue}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟702{current}.optimisticQueue.remove(𝓟700{changeId});
const 𝓟704{optimistic}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟[ty]681{CacheTransaction}._buildOptimisticSnapshot(𝓟702{current}.baseline);
𝓟[ty]681{CacheTransaction}._snapshot ⟵ 𝓟804{CONSTRUCTOR}(𝓟702{current}.baseline,𝓟704{optimistic},𝓟703{optimisticQueue});
}
function 𝓟733{_writeBaseline} (𝓟734{query}: [OOV]𝓟[ty]787{RawOperation},𝓟735{payload}: [OOV]𝓟[ty]506{NestedObject}): (𝓟736: [miss]𝓛[ty]10033{Void})
{
const 𝓟737{current}: [miss]𝓟[ty]811{CacheSnapshot} = 𝓟[ty]681{CacheTransaction}._snapshot;
const 𝓟738{baseline}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟1503{write}(𝓟[ty]681{CacheTransaction}._context,𝓟737{current}.baseline,𝓟734{query},𝓟735{payload}).snapshot;
const 𝓟739{editedNodeIds}: [miss]𝓛[ty]5956{Set} = 𝓟1503{write}(𝓟[ty]681{CacheTransaction}._context,𝓟737{current}.baseline,𝓟734{query},𝓟735{payload}).editedNodeIds;
const 𝓟740{writtenQueries}: [miss]𝓛[ty]5956{Set} = 𝓟1503{write}(𝓟[ty]681{CacheTransaction}._context,𝓟737{current}.baseline,𝓟734{query},𝓟735{payload}).writtenQueries;
𝓟460{addToSet}(𝓟[ty]681{CacheTransaction}._editedNodeIds,𝓟739{editedNodeIds})
𝓟460{addToSet}(𝓟[ty]681{CacheTransaction}._writtenQueries,𝓟740{writtenQueries})
const 𝓟741{optimistic}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟[ty]681{CacheTransaction}._buildOptimisticSnapshot(𝓟738{baseline});
𝓟[ty]681{CacheTransaction}._snapshot ⟵ 𝓟804{CONSTRUCTOR}(𝓟738{baseline},𝓟741{optimistic},𝓟737{current}.optimisticQueue);
}
function 𝓟705{evict} (𝓟706{_query}: [OOV]𝓟[ty]787{RawOperation}): (𝓟707: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8642{Object}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟748{_writeOptimistic} (𝓟749{query}: [OOV]𝓟[ty]787{RawOperation},𝓟750{payload}: [OOV]𝓟[ty]506{NestedObject}): (𝓟751: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]681{CacheTransaction}._deltas.push({query: 𝓟749{query},payload: 𝓟750{payload}})
const 𝓟752{optimistic}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟1503{write}(𝓟[ty]681{CacheTransaction}._context,𝓟[ty]681{CacheTransaction}._snapshot.optimistic,𝓟749{query},𝓟750{payload}).snapshot;
const 𝓟753{editedNodeIds}: [miss]𝓛[ty]5956{Set} = 𝓟1503{write}(𝓟[ty]681{CacheTransaction}._context,𝓟[ty]681{CacheTransaction}._snapshot.optimistic,𝓟749{query},𝓟750{payload}).editedNodeIds;
const 𝓟754{writtenQueries}: [miss]𝓛[ty]5956{Set} = 𝓟1503{write}(𝓟[ty]681{CacheTransaction}._context,𝓟[ty]681{CacheTransaction}._snapshot.optimistic,𝓟749{query},𝓟750{payload}).writtenQueries;
𝓟460{addToSet}(𝓟[ty]681{CacheTransaction}._writtenQueries,𝓟754{writtenQueries})
𝓟460{addToSet}(𝓟[ty]681{CacheTransaction}._editedNodeIds,𝓟753{editedNodeIds})
𝓟[ty]681{CacheTransaction}._snapshot ⟵ 𝓟804{CONSTRUCTOR}(𝓟[ty]681{CacheTransaction}._snapshot.baseline,𝓟752{optimistic},𝓟[ty]681{CacheTransaction}._snapshot.optimisticQueue);
}
function 𝓟695{write} (𝓟696{query}: [OOV]𝓟[ty]787{RawOperation},𝓟697{payload}: [OOV]𝓟[ty]506{NestedObject}): (𝓟698: 𝓛[ty]10033{Void})
{
if (𝓟[ty]681{CacheTransaction}._optimisticChangeId)
{
𝓟[ty]681{CacheTransaction}._writeOptimistic(𝓟696{query},𝓟697{payload})
}
else
{
𝓟[ty]681{CacheTransaction}._writeBaseline(𝓟696{query},𝓟697{payload})
}
}
}
Module: src/util/ast
function 𝓟755{variableDefaultsInOperation} (𝓟756{operation}: [OOV]𝓛[ty]22943{OperationDefinitionNode}): (𝓟757: 𝓛[ty]8642{Object})
{
const 𝓟758{defaults}: [miss]𝓛[ty]8642{Object} = {};
if (𝓟756{operation}.variableDefinitions)
{
{
const 𝓟759{definition} = 𝓛12589{$ArrayAccess}(𝓟756{operation}.variableDefinitions);
while (𝓛8744{Boolean})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟759{definition}.type.kind,𝓛8743{String}))
{
}
const 𝓟760{defaultValue} = 𝓟759{definition}.defaultValue;
𝓟758{defaults}.access(𝓟759{definition}.variable.name.value) ⟵ (𝓟235{isObject}(𝓟760{defaultValue}) ? 𝓟1517{valueFromNode}(𝓟760{defaultValue} as 𝓛[ty]22948{ValueNode}) : 𝓛12643{undefined};
}
}
}
return 𝓟757 = 𝓟758{defaults}
}
function 𝓟761{fragmentMapForDocument} (𝓟762{document}: [OOV]𝓛[ty]22936{DocumentNode}): (𝓟763: [OOV]𝓛[ty]2{<UNKNOWN>})
{
const 𝓟764{map}: [OOV]𝓛[ty]2{<UNKNOWN>} = {};
{
const 𝓟765{definition} = 𝓛12589{$ArrayAccess}(𝓟762{document}.definitions);
while (𝓛8744{Boolean})
{
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟765{definition}.kind,𝓛8743{String}))
{
}
𝓟764{map}.access(𝓟765{definition}.name.value) ⟵ 𝓟765{definition};
}
}
return 𝓟763 = 𝓟764{map}
}
function 𝓟766{selectionSetIsStatic} (𝓟767{selectionSet}: [OOV]𝓛[ty]22940{SelectionSetNode},𝓟768{fragmentGetter}: 𝓛[ty]8696{Function}): (𝓟769: 𝓛[ty]8666{Boolean})
{
{
const 𝓟770{selection} = 𝓛12589{$ArrayAccess}(𝓟767{selectionSet}.selections);
while (𝓛8744{Boolean})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟770{selection}.kind,𝓛8743{String}))
{
if (𝓛12569{ExclamationToken}(𝓟772{fieldIsStatic}(𝓟770{selection})))
{
return 𝓟769 = 𝓛8744{Boolean}
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟770{selection}.selectionSet,𝓛12569{ExclamationToken}(𝓟766{selectionSetIsStatic}(𝓟770{selection}.selectionSet,𝓟768{fragmentGetter}))))
{
return 𝓟769 = 𝓛8744{Boolean}
}
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟770{selection}.kind,𝓛8743{String}))
{
if (𝓛12569{ExclamationToken}(𝓟768{fragmentGetter}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
const 𝓟771{fragmentSet} = 𝓟768{fragmentGetter}(𝓟770{selection}.name.value);
if (𝓛12569{ExclamationToken}(𝓟771{fragmentSet}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓟770{selection}.name.value))
}
if (𝓛12569{ExclamationToken}(𝓟766{selectionSetIsStatic}(𝓟771{fragmentSet},𝓟768{fragmentGetter})))
{
return 𝓟769 = 𝓛8744{Boolean}
}
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟770{selection}.kind,𝓛8743{String}))
{
if (𝓛12569{ExclamationToken}(𝓟766{selectionSetIsStatic}(𝓟770{selection}.selectionSet,𝓟768{fragmentGetter})))
{
return 𝓟769 = 𝓛8744{Boolean}
}
}
else
{
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓟770{selection} as any.kind))
}
}
}
}
}
return 𝓟769 = 𝓛8744{Boolean}
}
function 𝓟772{fieldIsStatic} (𝓟773{field}: [OOV]𝓛[ty]22944{FieldNode}): (𝓟774: [OOV]any)
{
const 𝓟775{isActuallyStatic}: [miss]𝓛[ty]8666{Boolean} = 𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟776{fieldHasAlias}(𝓟773{field})),𝓛12569{ExclamationToken}(𝓟779{fieldIsParameterized}(𝓟773{field})));
return 𝓟774 = 𝓛12546{BarBarToken}(𝓟775{isActuallyStatic},𝓟782{fieldHasStaticDirective}(𝓟773{field}))
}
function 𝓟776{fieldHasAlias} (𝓟777{field}: [OOV]𝓛[ty]22944{FieldNode}): (𝓟778: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟778 = 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟777{field}.alias))
}
function 𝓟779{fieldIsParameterized} (𝓟780{field}: [OOV]𝓛[ty]22944{FieldNode}): (𝓟781: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟781 = 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓛12592{AmpersandAmpersandToken}(𝓟780{field}.arguments,𝓟780{field}.arguments.length)))
}
function 𝓟782{fieldHasStaticDirective} (𝓟783{_}: [OOV]𝓛[ty]22944{FieldNode}): (𝓟784: [OOV]any)
{
}
Module: src/schema
type 𝓟[ty]785{QuerySnapshot} = {query: 𝓟[ty]787{RawOperation}, payload: 𝓟[ty]506{NestedObject}}
type 𝓛[ty]10051{String} = 𝓛[ty]10051{String}
type 𝓟[ty]787{RawOperation} = {fragmentName: 𝓛[ty]10051{String}, document: 𝓛[ty]22936{DocumentNode}, variables: 𝓟[ty]506{NestedObject}, fromFragmentDocument: 𝓛[ty]8666{Boolean}, rootId: 𝓛[ty]10051{String}}
type 𝓛[ty]10051{String} = 𝓛[ty]10051{String}
type 𝓛[ty]10051{String} = 𝓛[ty]10051{String}
type 𝓛[ty]8655{Number} = 𝓛[ty]8655{Number}
type 𝓟[ty]791{OperationInstance} = {parsedQuery: 𝓟[ty]1073{ParsedQueryNodeMap}, variables: 𝓟[ty]506{NestedObject}, info: 𝓟[ty]1217{QueryInfo}, rootId: 𝓛[ty]10051{String}, isStatic: 𝓛[ty]8666{Boolean}}
const 𝓟792{StaticNodeId} = {QueryRoot: 𝓛8745{Number},MutationRoot: 𝓛8745{Number},SubscriptionRoot: 𝓛8745{Number}};
type 𝓟[ty]793{GraphSnapshot} = {access: (𝓛[ty]10051{String})->𝓟[ty]794{NodeSnapshot}}
type 𝓟[ty]794{NodeSnapshot} = {type: 𝓛[ty]8655{Number}, inbound: 𝓛[ty]8670{Array}, outbound: 𝓛[ty]8670{Array}, data: 𝓟[ty]513{NestedValue}}
type 𝓛[ty]8655{Number} = 𝓛[ty]8655{Number}
const 𝓟796{NodeSnapshotType} = {EntitySnapshot: 𝓛8745{Number},ParameterizedValueSnapshot: 𝓛8745{Number}};
function 𝓟797{isSerializable} (𝓟798{value}: [OOV]any,𝓟799{allowUndefined}: 𝓛[ty]8666{Boolean}): (𝓟800: 𝓛[ty]8666{Boolean})
{
if (𝓟232{isScalar}(𝓟798{value}))
{
const 𝓟801{isNaNValue}: [miss]𝓛[ty]8666{Boolean} = 𝓛8745{Number}.isNaN(𝓟798{value} as any);
return 𝓟800 = (𝓟799{allowUndefined} ? 𝓛12569{ExclamationToken}(𝓟801{isNaNValue}) : 𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟801{isNaNValue}),𝓛12612{ExclamationEqualsEqualsToken}(𝓟798{value},𝓛12643{undefined}))
}
if (𝓟235{isObject}(𝓟798{value}))
{
{
const 𝓟802{propName}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓛8741{Object}.getOwnPropertyNames(𝓟798{value}));
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟797{isSerializable}(𝓟798{value}.access(𝓟802{propName}),𝓟799{allowUndefined})))
{
return 𝓟800 = 𝓛8744{Boolean}
}
}
}
return 𝓟800 = 𝓛8744{Boolean}
}
if (𝓛8757{Array}.isArray(𝓟798{value}))
{
{
const 𝓟803{element} = 𝓛12589{$ArrayAccess}(𝓟798{value});
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟797{isSerializable}(𝓟803{element},𝓟799{allowUndefined})))
{
return 𝓟800 = 𝓛8744{Boolean}
}
}
}
return 𝓟800 = 𝓛8744{Boolean}
}
return 𝓟800 = 𝓛8744{Boolean}
}
Module: src/apollo/index
Module: src/nodes/index
Module: src/context/Tracer
type 𝓟[ty]816{Tracer} = {writeEnd: (𝓟[ty]791{OperationInstance},𝓟[ty]817{WriteInfo},any)->𝓛[ty]10033{Void}, transactionStart: ()->any, warning: (𝓛[ty]10051{String},𝓛[ty]8670{Array})->𝓛[ty]10033{Void}, readStart: (𝓟[ty]787{RawOperation})->any, writeStart: (𝓟[ty]787{RawOperation},𝓟[ty]506{NestedObject})->any, transactionEnd: (any,any)->𝓛[ty]10033{Void}, broadcastEnd: (𝓟[ty]819{BroadcastInfo},any)->𝓛[ty]10033{Void}, broadcastStart: (𝓟[ty]819{BroadcastInfo})->any, readEnd: (𝓟[ty]791{OperationInstance},𝓟[ty]818{ReadInfo},any)->𝓛[ty]10033{Void}}
type 𝓟[ty]817{WriteInfo} = {payload: 𝓟[ty]506{NestedObject}, newSnapshot: 𝓟[ty]514{EditedSnapshot}, warnings: 𝓛[ty]8670{Array}}
type 𝓟[ty]818{ReadInfo} = {result: 𝓟[ty]984{QueryResult}, cacheHit: 𝓛[ty]8666{Boolean}}
type 𝓟[ty]819{BroadcastInfo} = {snapshot: 𝓟[ty]811{CacheSnapshot}, editedNodeIds: 𝓛[ty]5956{Set}}
Module: src/Cache
type 𝓟[ty]820{TransactionCallback} = (𝓟[ty]681{CacheTransaction})->𝓛[ty]10033{Void}
function 𝓟821{CONSTRUCTOR} (𝓟822{config}: [OOV]𝓟[ty]399{Configuration}): (𝓟[ty]827{Cache})
{
const 𝓟[ty]827{Cache};
const 𝓟[ty]827{Cache};
𝓟[ty]827{Cache}._observers ⟵ 𝓛8757{Array}();
const 𝓟826{initialGraphSnapshot}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟1382{CONSTRUCTOR}();
𝓟[ty]827{Cache}._snapshot ⟵ 𝓟804{CONSTRUCTOR}(𝓟826{initialGraphSnapshot},𝓟826{initialGraphSnapshot},𝓟1183{CONSTRUCTOR}());
𝓟[ty]827{Cache}._context ⟵ 𝓟401{CONSTRUCTOR}(𝓟822{config});
}
class 𝓟[ty]827{Cache} extends 𝓟[ty]1380{Queryable}{
𝓟829{_context}: 𝓟[ty]406{CacheContext};
𝓟830{_snapshot}: 𝓟[ty]811{CacheSnapshot};
𝓟831{_observers}: 𝓛[ty]8670{Array};
function 𝓟851{read} (𝓟852{query}: [OOV]𝓟[ty]787{RawOperation},𝓟853{optimistic}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8666{Boolean})): (𝓟854: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓛[ty]8642{Object}))
{
return 𝓟854 = 𝓟997{read}(𝓟[ty]827{Cache}._context,𝓟852{query},(𝓟853{optimistic} ? 𝓟[ty]827{Cache}._snapshot.optimistic : 𝓟[ty]827{Cache}._snapshot.baseline)
}
function 𝓟832{transformDocument} (𝓟833{document}: [OOV]𝓛[ty]22936{DocumentNode}): (𝓟834: [OOV]𝓛[ty]22936{DocumentNode})
{
return 𝓟834 = 𝓟[ty]827{Cache}._context.transformDocument(𝓟833{document})
}
function 𝓟835{restore} (𝓟836{data}: [OOV]𝓟[ty]793{GraphSnapshot},𝓟837{migrationMap}: [OOV]𝓟[ty]917{MigrationMap},𝓟838{verifyQuery}: [OOV]𝓟[ty]787{RawOperation}): (𝓟839: [miss]𝓛[ty]10033{Void})
{
const 𝓟840{cacheSnapshot}: [miss]𝓟[ty]811{CacheSnapshot} = 𝓟1448{restore}(𝓟836{data},𝓟[ty]827{Cache}._context).cacheSnapshot;
const 𝓟841{editedNodeIds}: [miss]𝓛[ty]5956{Set} = 𝓟1448{restore}(𝓟836{data},𝓟[ty]827{Cache}._context).editedNodeIds;
const 𝓟842{migrated}: [miss]𝓟[ty]811{CacheSnapshot} = 𝓟925{migrate}(𝓟840{cacheSnapshot},𝓟837{migrationMap});
if (𝓛12592{AmpersandAmpersandToken}(𝓟838{verifyQuery},𝓛12569{ExclamationToken}(𝓟997{read}(𝓟[ty]827{Cache}._context,𝓟838{verifyQuery},𝓟842{migrated}.baseline).complete)))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
𝓟[ty]827{Cache}._setSnapshot(𝓟842{migrated},𝓟841{editedNodeIds})
}
function 𝓟895{getSnapshot} (): (𝓟896: (𝓟[ty]681{CacheTransaction} ≠ 𝓟[ty]811{CacheSnapshot}))
{
return 𝓟896 = 𝓟[ty]827{Cache}._snapshot
}
function 𝓟858{watch} (𝓟859{query}: [OOV]𝓟[ty]787{RawOperation},𝓟860{callback}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟861: 𝓛[ty]8696{Function})
{
const 𝓟862{observer}: [miss]𝓟[ty]485{QueryObserver} = 𝓟477{CONSTRUCTOR}(𝓟[ty]827{Cache}._context,𝓟859{query},𝓟[ty]827{Cache}._snapshot.optimistic,𝓟860{callback});
𝓟[ty]827{Cache}._observers.push(𝓟862{observer})
function 𝓟863{$Lambda0} (): (𝓟864: [miss]𝓛[ty]10033{Void})
{
return 𝓟864 = 𝓟[ty]827{Cache}._removeObserver(𝓟862{observer})
}
return 𝓟861 = 𝓟863{$Lambda0}
}
function 𝓟897{$Async_reset} (): (𝓟898: 𝓛[ty]8654{Promise})
{
const 𝓟899{allIds}: [miss]𝓛[ty]5956{Set} = 𝓛2997{Set}.CONSTRUCTOR(𝓟[ty]827{Cache}._snapshot.optimistic.allNodeIds());
const 𝓟900{baseline}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟1382{CONSTRUCTOR}();
const 𝓟901{optimistic}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟900{baseline};
const 𝓟902{optimisticQueue}: [miss]𝓟[ty]1188{OptimisticUpdateQueue} = 𝓟1183{CONSTRUCTOR}();
𝓟[ty]827{Cache}._setSnapshot(𝓟804{CONSTRUCTOR}(𝓟900{baseline},𝓟901{optimistic},𝓟902{optimisticQueue}),𝓟899{allIds})
}
function 𝓟889{rollback} (𝓟890{changeId}: 𝓛[ty]10051{String}): (𝓟891: [miss]𝓛[ty]10033{Void})
{
function 𝓟892{$Lambda2} (𝓟893{t}): (𝓟894: [miss]𝓛[ty]10033{Void})
{
return 𝓟894 = 𝓟893{t}.rollback(𝓟890{changeId})
}
𝓟[ty]827{Cache}.transaction(𝓟892{$Lambda2})
}
function 𝓟855{getEntity} (𝓟856{id}: 𝓛[ty]10051{String}): (𝓟857: [OOV]any)
{
return 𝓟857 = 𝓟[ty]827{Cache}._snapshot.optimistic.getNodeData(𝓟856{id})
}
function 𝓟848{evict} (𝓟849{_query}: [OOV]𝓟[ty]787{RawOperation}): (𝓟850: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8642{Object}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟910{_setSnapshot} (𝓟911{snapshot}: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓟[ty]811{CacheSnapshot}),𝓟912{editedNodeIds}: (𝓛[ty]10051{String} ≠ 𝓛[ty]5956{Set})): (𝓟913: 𝓛[ty]10033{Void})
{
𝓟[ty]827{Cache}._snapshot ⟵ 𝓟911{snapshot};
let 𝓟914{tracerContext};
if (𝓟[ty]827{Cache}._context.tracer.broadcastStart)
{
𝓟914{tracerContext} ⟵ 𝓟[ty]827{Cache}._context.tracer.broadcastStart({snapshot: 𝓟911{snapshot},editedNodeIds: 𝓟912{editedNodeIds}});
}
{
const 𝓟915{observer}: [miss]𝓟[ty]485{QueryObserver} = 𝓛12589{$ArrayAccess}(𝓟[ty]827{Cache}._observers);
while (𝓛8744{Boolean})
{
𝓟915{observer}.consumeChanges(𝓟911{snapshot}.optimistic,𝓟912{editedNodeIds})
}
}
if (𝓟[ty]827{Cache}._context.onChange)
{
𝓟[ty]827{Cache}._context.onChange(𝓟[ty]827{Cache}._snapshot,𝓟912{editedNodeIds})
}
if (𝓟[ty]827{Cache}._context.tracer.broadcastEnd)
{
𝓟[ty]827{Cache}._context.tracer.broadcastEnd({snapshot: 𝓟911{snapshot},editedNodeIds: 𝓟912{editedNodeIds}},𝓟914{tracerContext})
}
}
function 𝓟879{transaction} (𝓟880{changeIdOrCallback}: [OOV]any,𝓟881{callback}: [OOV]𝓟[ty]820{TransactionCallback}): (𝓟882: 𝓛[ty]8666{Boolean})
{
const 𝓟883{tracer}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]827{Cache}._context.tracer;
let 𝓟884{changeId};
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟881{callback}),𝓛8743{String}))
{
𝓟881{callback} ⟵ 𝓟880{changeIdOrCallback} as 𝓟[ty]820{TransactionCallback};
}
else
{
𝓟884{changeId} ⟵ 𝓟880{changeIdOrCallback} as 𝓛[ty]10051{String};
}
let 𝓟885{tracerContext};
if (𝓟883{tracer}.transactionStart)
{
𝓟885{tracerContext} ⟵ 𝓟883{tracer}.transactionStart();
}
const 𝓟886{transaction}: [miss]𝓟[ty]681{CacheTransaction} = 𝓟674{CONSTRUCTOR}(𝓟[ty]827{Cache}._context,𝓟[ty]827{Cache}._snapshot,𝓟884{changeId});
{
𝓟881{callback}(𝓟886{transaction})
}
const 𝓟887{snapshot}: [miss]𝓟[ty]811{CacheSnapshot} = 𝓟886{transaction}.commit().snapshot;
const 𝓟888{editedNodeIds}: [miss]𝓛[ty]5956{Set} = 𝓟886{transaction}.commit().editedNodeIds;
𝓟[ty]827{Cache}._setSnapshot(𝓟887{snapshot},𝓟888{editedNodeIds})
if (𝓟883{tracer}.transactionEnd)
{
𝓟883{tracer}.transactionEnd(𝓛12643{undefined},𝓟885{tracerContext})
}
return 𝓟882 = 𝓛8744{Boolean}
}
function 𝓟903{_removeObserver} (𝓟904{observer}: (𝓟[ty]278{QueryError} ≠ 𝓟[ty]485{QueryObserver})): (𝓟905: 𝓛[ty]10033{Void})
{
function 𝓟906{$Lambda3} (𝓟907{o}): (𝓟908: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟908 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟907{o},𝓟904{observer})
}
const 𝓟909{index}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]827{Cache}._observers.findIndex(𝓟906{$Lambda3});
if (𝓛1{<UNKNOWN>}(𝓟909{index},𝓛8745{Number}))
{
}
𝓟[ty]827{Cache}._observers.splice(𝓟909{index},𝓛8745{Number})
}
function 𝓟865{write} (𝓟866{query}: [OOV]𝓟[ty]787{RawOperation},𝓟867{payload}: [OOV]𝓟[ty]506{NestedObject}): (𝓟868: 𝓛[ty]10033{Void})
{
function 𝓟869{$Lambda1} (𝓟870{t}): (𝓟871: [miss]𝓛[ty]10033{Void})
{
return 𝓟871 = 𝓟870{t}.write(𝓟866{query},𝓟867{payload})
}
𝓟[ty]827{Cache}.transaction(𝓟869{$Lambda1})
}
function 𝓟843{extract} (𝓟844{optimistic}: (𝓟[ty]1188{OptimisticUpdateQueue} ≠ 𝓛[ty]8666{Boolean}),𝓟845{pruneQuery}: [OOV]𝓟[ty]787{RawOperation}): (𝓟846: [OOV]𝓟[ty]793{GraphSnapshot})
{
const 𝓟847{cacheSnapshot}: [miss]𝓟[ty]1387{GraphSnapshot} = (𝓟844{optimistic} ? 𝓟[ty]827{Cache}._snapshot.optimistic : 𝓟[ty]827{Cache}._snapshot.baseline;
return 𝓟846 = 𝓟247{extract}((𝓟845{pruneQuery} ? 𝓟656{prune}(𝓟[ty]827{Cache}._context,𝓟847{cacheSnapshot},𝓟845{pruneQuery}).snapshot : 𝓟847{cacheSnapshot},𝓟[ty]827{Cache}._context)
}
}
Module: src/apollo/Queryable
function 𝓟932{CONSTRUCTOR} (): (𝓟[ty]936{ApolloQueryable})
{
const 𝓟[ty]936{ApolloQueryable};
const 𝓟[ty]936{ApolloQueryable};
}
class 𝓟[ty]936{ApolloQueryable} extends 𝓛[ty]2{<UNKNOWN>}{
𝓟938{_queryable}: [OOV]𝓟[ty]1380{Queryable};
function 𝓟945{read} (𝓟946{options}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟947: [OOV]any)
{
const 𝓟948{rawOperation}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟663{buildRawOperationFromQuery}(𝓟946{options}.query,𝓟946{options}.variables,𝓟946{options}.rootId);
const 𝓟949{result}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]936{ApolloQueryable}._queryable.read(𝓟948{rawOperation},𝓟946{options}.optimistic).result;
const 𝓟950{complete}: [miss]𝓛[ty]8666{Boolean} = 𝓟[ty]936{ApolloQueryable}._queryable.read(𝓟948{rawOperation},𝓟946{options}.optimistic).complete;
if (𝓛12569{ExclamationToken}(𝓟950{complete}))
{
𝓟281{CONSTRUCTOR}(𝓛8743{String})
}
return 𝓟947 = 𝓟949{result}
}
function 𝓟951{readQuery} (𝓟952{options}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟953{optimistic}: (𝓟[ty]344{EntitySnapshot} ≠ 𝓛[ty]8666{Boolean})): (𝓟954: [OOV]any)
{
return 𝓟954 = 𝓟[ty]936{ApolloQueryable}.read({query: 𝓟952{options}.query,variables: 𝓟952{options}.variables,optimistic: 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟953{optimistic}))})
}
function 𝓟974{transformDocument} (𝓟975{doc}: [OOV]𝓛[ty]22936{DocumentNode}): (𝓟976: [OOV]𝓛[ty]22936{DocumentNode})
{
return 𝓟976 = 𝓟[ty]936{ApolloQueryable}._queryable.transformDocument(𝓟975{doc})
}
function 𝓟968{writeFragment} (𝓟969{options}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟970: 𝓛[ty]10033{Void})
{
const 𝓟971{rawOperation}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟668{buildRawOperationFromFragment}(𝓟969{options}.fragment,𝓟969{options}.id,𝓟969{options}.variables as 𝓟[ty]506{NestedObject},𝓟969{options}.fragmentName);
𝓟[ty]936{ApolloQueryable}._queryable.write(𝓟971{rawOperation},𝓟969{options}.data)
}
function 𝓟964{writeQuery} (𝓟965{options}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟966: 𝓛[ty]10033{Void})
{
const 𝓟967{rawOperation}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟663{buildRawOperationFromQuery}(𝓟965{options}.query,𝓟965{options}.variables as 𝓟[ty]506{NestedObject});
𝓟[ty]936{ApolloQueryable}._queryable.write(𝓟967{rawOperation},𝓟965{options}.data)
}
function 𝓟955{readFragment} (𝓟956{options}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟957{optimistic}: (𝓟[ty]1188{OptimisticUpdateQueue} ≠ 𝓛[ty]8666{Boolean})): (𝓟958: [OOV]any)
{
const 𝓟959{rawOperation}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟668{buildRawOperationFromFragment}(𝓟956{options}.fragment,𝓟956{options}.id,𝓟956{options}.variables as 𝓟[ty]506{NestedObject},𝓟956{options}.fragmentName);
return 𝓟958 = 𝓟[ty]936{ApolloQueryable}._queryable.read(𝓟959{rawOperation},𝓟957{optimistic}).result as any
}
function 𝓟939{diff} (𝓟940{options}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟941: [OOV]𝓛[ty]2{<UNKNOWN>})
{
const 𝓟942{rawOperation}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟663{buildRawOperationFromQuery}(𝓟940{options}.query,𝓟940{options}.variables);
const 𝓟943{result}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]936{ApolloQueryable}._queryable.read(𝓟942{rawOperation},𝓟940{options}.optimistic).result;
const 𝓟944{complete}: [miss]𝓛[ty]8666{Boolean} = 𝓟[ty]936{ApolloQueryable}._queryable.read(𝓟942{rawOperation},𝓟940{options}.optimistic).complete;
if (𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟940{options}.returnPartialData,𝓛8744{Boolean}),𝓛12569{ExclamationToken}(𝓟944{complete})))
{
𝓟281{CONSTRUCTOR}(𝓛8743{String})
}
return 𝓟941 = {result: 𝓟943{result},complete: 𝓟944{complete}}
}
function 𝓟972{writeData} (): (𝓟973: 𝓛[ty]10033{Void})
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟980{evict} (𝓟981{options}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟982: [OOV]𝓛[ty]2{<UNKNOWN>})
{
const 𝓟983{rawOperation}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟663{buildRawOperationFromQuery}(𝓟981{options}.query,𝓟981{options}.variables);
return 𝓟982 = 𝓟[ty]936{ApolloQueryable}._queryable.evict(𝓟983{rawOperation})
}
function 𝓟977{transformForLink} (𝓟978{document}: [OOV]𝓛[ty]22936{DocumentNode}): (𝓟979: [OOV]𝓛[ty]22936{DocumentNode})
{
return 𝓟979 = 𝓟1522{removeDirectivesFromDocument}(𝓛8757{Array}({name: 𝓛8743{String}}),𝓟978{document})
}
function 𝓟960{write} (𝓟961{options}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟962: 𝓛[ty]10033{Void})
{
const 𝓟963{rawOperation}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟663{buildRawOperationFromQuery}(𝓟961{options}.query,𝓟961{options}.variables as 𝓟[ty]506{NestedObject},𝓟961{options}.dataId);
𝓟[ty]936{ApolloQueryable}._queryable.write(𝓟963{rawOperation},𝓟961{options}.result)
}
}
Module: src/operations/read
type 𝓟[ty]984{QueryResult} = {result: 𝓟[ty]506{NestedObject}, complete: 𝓛[ty]8666{Boolean}}
type 𝓟[ty]985{QueryResultWithNodeIds} extends 𝓟[ty]984{QueryResult} = {nodeIds: 𝓛[ty]5956{Set}}
function 𝓟986{read} (𝓟987{context}: 𝓟[ty]406{CacheContext},𝓟988{raw}: [OOV]𝓟[ty]787{RawOperation},𝓟989{snapshot}: (𝓟[ty]406{CacheContext} ≠ 𝓟[ty]1387{GraphSnapshot})): (𝓟990: [OOV]𝓟[ty]984{QueryResult})
{
}
function 𝓟991{read} (𝓟992{context}: 𝓟[ty]406{CacheContext},𝓟993{raw}: [OOV]𝓟[ty]787{RawOperation},𝓟994{snapshot}: (𝓟[ty]406{CacheContext} ≠ 𝓟[ty]1387{GraphSnapshot}),𝓟995{includeNodeIds}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean})): (𝓟996: [OOV]𝓟[ty]985{QueryResultWithNodeIds})
{
}
function 𝓟997{read} (𝓟998{context}: 𝓟[ty]406{CacheContext},𝓟999{raw}: [OOV]𝓟[ty]787{RawOperation},𝓟1000{snapshot}: 𝓟[ty]1387{GraphSnapshot},𝓟1001{includeNodeIds}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8666{Boolean})): (𝓟1002)
{
let 𝓟1003{tracerContext};
if (𝓟998{context}.tracer.readStart)
{
𝓟1003{tracerContext} ⟵ 𝓟998{context}.tracer.readStart(𝓟999{raw});
}
const 𝓟1004{operation}: [OOV]𝓟[ty]791{OperationInstance} = 𝓟998{context}.parseOperation(𝓟999{raw});
let 𝓟1005{queryResult}: [miss]𝓛[ty]8689{Partial} = 𝓟1000{snapshot}.readCache.get(𝓟1004{operation}) as 𝓛[ty]8689{Partial};
let 𝓟1006{cacheHit}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
if (𝓛12569{ExclamationToken}(𝓟1005{queryResult}))
{
𝓟1006{cacheHit} ⟵ 𝓛8744{Boolean};
const 𝓟1007{staticResult} = 𝓟1000{snapshot}.getNodeData(𝓟1004{operation}.rootId);
let 𝓟1008{result} = 𝓟1007{staticResult};
if (𝓛12569{ExclamationToken}(𝓟1004{operation}.isStatic))
{
𝓟1008{result} ⟵ 𝓟1028{_walkAndOverlayDynamicValues}(𝓟1004{operation},𝓟998{context},𝓟1000{snapshot},𝓟1007{staticResult});
}
const 𝓟1009{complete}: [miss]𝓛[ty]8666{Boolean} = 𝓟1057{_visitSelection}(𝓟1004{operation},𝓟998{context},𝓟1008{result},𝓟1001{includeNodeIds}).complete;
const 𝓟1010{nodeIds}: [miss]𝓛[ty]5956{Set} = 𝓟1057{_visitSelection}(𝓟1004{operation},𝓟998{context},𝓟1008{result},𝓟1001{includeNodeIds}).nodeIds;
𝓟1005{queryResult} ⟵ {result: 𝓟1008{result},complete: 𝓟1009{complete},nodeIds: 𝓟1010{nodeIds}};
𝓟1000{snapshot}.readCache.set(𝓟1004{operation},𝓟1005{queryResult} as 𝓟[ty]984{QueryResult})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟1001{includeNodeIds},𝓛12569{ExclamationToken}(𝓟1005{queryResult}.nodeIds)))
{
𝓟1006{cacheHit} ⟵ 𝓛8744{Boolean};
const 𝓟1011{complete}: [miss]𝓛[ty]8666{Boolean} = 𝓟1057{_visitSelection}(𝓟1004{operation},𝓟998{context},𝓟1005{queryResult}.result,𝓟1001{includeNodeIds}).complete;
const 𝓟1012{nodeIds}: [miss]𝓛[ty]5956{Set} = 𝓟1057{_visitSelection}(𝓟1004{operation},𝓟998{context},𝓟1005{queryResult}.result,𝓟1001{includeNodeIds}).nodeIds;
𝓟1005{queryResult}.complete ⟵ 𝓟1011{complete};
𝓟1005{queryResult}.nodeIds ⟵ 𝓟1012{nodeIds};
}
if (𝓟998{context}.tracer.readEnd)
{
const 𝓟1013{result}: [miss]𝓛[ty]8642{Object} = {result: 𝓟1005{queryResult} as 𝓟[ty]984{QueryResult},cacheHit: 𝓟1006{cacheHit}};
𝓟998{context}.tracer.readEnd(𝓟1004{operation},𝓟1013{result},𝓟1003{tracerContext})
}
return 𝓟1002 = 𝓟1005{queryResult}
}
function 𝓟1014{CONSTRUCTOR} (𝓟1015{value}: [OOV]𝓟[ty]506{NestedObject},𝓟1016{containerId}: 𝓛[ty]10051{String},𝓟1017{parsedMap}: [OOV]𝓟[ty]1073{ParsedQueryNodeMap},𝓟1018{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟[ty]1022{OverlayWalkNode})
{
const 𝓟[ty]1022{OverlayWalkNode};
const 𝓟[ty]1022{OverlayWalkNode};
𝓟[ty]1022{OverlayWalkNode}.parsedMap ⟵ 𝓟1017{parsedMap};
𝓟[ty]1022{OverlayWalkNode}.value ⟵ 𝓟1015{value};
𝓟[ty]1022{OverlayWalkNode}.containerId ⟵ 𝓟1016{containerId};
𝓟[ty]1022{OverlayWalkNode}.path ⟵ 𝓟1018{path};
}
class 𝓟[ty]1022{OverlayWalkNode}{
𝓟1024{value}: [OOV]𝓟[ty]506{NestedObject};
𝓟1025{containerId}: 𝓛[ty]10051{String};
𝓟1026{parsedMap}: [OOV]𝓟[ty]1073{ParsedQueryNodeMap};
𝓟1027{path}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
}
function 𝓟1028{_walkAndOverlayDynamicValues} (𝓟1029{query}: [OOV]𝓟[ty]791{OperationInstance},𝓟1030{context}: 𝓟[ty]406{CacheContext},𝓟1031{snapshot}: 𝓟[ty]1387{GraphSnapshot},𝓟1032{result}: [OOV]any): (𝓟1033: [OOV]any)
{
const 𝓟1034{rootSnapshot}: [miss]𝓛[ty]8614{Readonly} = 𝓟1031{snapshot}.getNodeSnapshot(𝓟1029{query}.rootId);
if (𝓟241{isNil}(𝓟1034{rootSnapshot}))
{
return 𝓟1033 = 𝓟1032{result}
}
const 𝓟1035{newResult} = 𝓟1052{_wrapValue}(𝓟1032{result},𝓟1030{context});
const 𝓟1036{queue}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓟1014{CONSTRUCTOR}(𝓟1035{newResult},𝓟1029{query}.rootId,𝓟1029{query}.parsedQuery,𝓛8757{Array}()));
while (𝓟1036{queue}.length)
{
const 𝓟1037{walkNode}: [miss]𝓟[ty]1022{OverlayWalkNode} = 𝓟1036{queue}.pop();
const 𝓟1038{value}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1037{walkNode}.value;
const 𝓟1039{parsedMap}: [OOV]𝓟[ty]1073{ParsedQueryNodeMap} = 𝓟1037{walkNode}.parsedMap;
let 𝓟1040{containerId}: [miss]𝓛[ty]10051{String} = 𝓟1037{walkNode}.containerId;
let 𝓟1041{path}: [miss]𝓛[ty]8670{Array} = 𝓟1037{walkNode}.path;
const 𝓟1042{valueId}: [miss]𝓛[ty]10051{String} = 𝓟1030{context}.entityIdForValue(𝓟1038{value});
if (𝓟1042{valueId})
{
𝓟1040{containerId} ⟵ 𝓟1042{valueId};
𝓟1041{path} ⟵ 𝓛8757{Array}();
}
{
const 𝓟1043{key}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1039{parsedMap});
while (𝓛8744{Boolean})
{
const 𝓟1044{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1039{parsedMap}.access(𝓟1043{key});
let 𝓟1045{child};
let 𝓟1046{fieldName}: [miss]𝓛[ty]10051{String} = 𝓟1043{key};
𝓟1046{fieldName} ⟵ (𝓟1044{node}.schemaName ? 𝓟1044{node}.schemaName : 𝓟1043{key};
if (𝓟1044{node}.args)
{
let 𝓟1047{childId}: [miss]𝓛[ty]10051{String} = 𝓟651{nodeIdForParameterizedValue}(𝓟1040{containerId},𝓛8757{Array}(𝓛12587{$Spread}(𝓟1041{path}),𝓟1046{fieldName}),𝓟1044{node}.args);
let 𝓟1048{childSnapshot}: [miss]𝓛[ty]8614{Readonly} = 𝓟1031{snapshot}.getNodeSnapshot(𝓟1047{childId});
if (𝓛12569{ExclamationToken}(𝓟1048{childSnapshot}))
{
let 𝓟1049{typeName}: [miss]𝓛[ty]10051{String} = 𝓟1038{value}.__typename as 𝓛[ty]10051{String};
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟1049{typeName}),𝓛12559{EqualsEqualsEqualsToken}(𝓟1040{containerId},𝓟792{StaticNodeId}.QueryRoot)))
{
𝓟1049{typeName} ⟵ 𝓛8743{String};
}
const 𝓟1050{redirect}: [OOV]any = 𝓟1515{lodashGet}(𝓟1030{context}.resolverRedirects,𝓛8757{Array}(𝓟1049{typeName},𝓟1046{fieldName})) as any;
if (𝓟1050{redirect})
{
𝓟1047{childId} ⟵ 𝓟1050{redirect}(𝓟1044{node}.args);
if (𝓛12569{ExclamationToken}(𝓟241{isNil}(𝓟1047{childId})))
{
𝓟1048{childSnapshot} ⟵ 𝓟1031{snapshot}.getNodeSnapshot(𝓟1047{childId});
}
}
}
if (𝓛12569{ExclamationToken}(𝓟1048{childSnapshot}))
{
}
𝓟1045{child} ⟵ 𝓟1048{childSnapshot}.data;
}
else
{
𝓟1045{child} ⟵ 𝓟1038{value}.access(𝓟1046{fieldName});
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓟1044{node}.hasParameterizedChildren,𝓟1044{node}.children),𝓛12612{ExclamationEqualsEqualsToken}(𝓟1045{child},𝓛12643{undefined})))
{
if (𝓛8757{Array}.isArray(𝓟1045{child}))
{
𝓟1045{child} ⟵ 𝓛8757{Array}(𝓛12587{$Spread}(𝓟1045{child}));
{
let 𝓟1051{i}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟1045{child}.length,𝓛8745{Number});
while (𝓛12596{GreaterThanEqualsToken}(𝓟1051{i},𝓛8745{Number}))
{
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1045{child}.access(𝓟1051{i}),𝓛12643{undefined}))
{
}
𝓟1045{child}.access(𝓟1051{i}) ⟵ 𝓟1052{_wrapValue}(𝓟1045{child}.access(𝓟1051{i}),𝓟1030{context});
𝓟1036{queue}.push(𝓟1014{CONSTRUCTOR}(𝓟1045{child}.access(𝓟1051{i}) as 𝓟[ty]506{NestedObject},𝓟1040{containerId},𝓟1044{node}.children,𝓛8757{Array}(𝓛12587{$Spread}(𝓟1041{path}),𝓟1046{fieldName},𝓟1051{i})))
}
𝓛12614{POST_MinusMinusToken}(𝓟1051{i})
}
}
}
else
{
𝓟1045{child} ⟵ 𝓟1052{_wrapValue}(𝓟1045{child},𝓟1030{context});
𝓟1036{queue}.push(𝓟1014{CONSTRUCTOR}(𝓟1045{child} as 𝓟[ty]506{NestedObject},𝓟1040{containerId},𝓟1044{node}.children,𝓛8757{Array}(𝓛12587{$Spread}(𝓟1041{path}),𝓟1046{fieldName})))
}
}
𝓟1038{value}.access(𝓟1043{key}) ⟵ 𝓟1045{child};
}
}
}
return 𝓟1033 = 𝓟1035{newResult}
}
function 𝓟1052{_wrapValue} (𝓟1053{value}: [OOV]any,𝓟1054{context}: 𝓟[ty]406{CacheContext}): (𝓟1055: [OOV]any)
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1053{value},𝓛12643{undefined}))
{
return 𝓟1055 = {}
}
if (𝓛8757{Array}.isArray(𝓟1053{value}))
{
return 𝓟1055 = 𝓛8757{Array}(𝓛12587{$Spread}(𝓟1053{value}))
}
if (𝓟235{isObject}(𝓟1053{value}))
{
const 𝓟1056{newValue}: [miss]𝓛[ty]8642{Object} = {};
if (𝓛12592{AmpersandAmpersandToken}(𝓟1054{context}.entityTransformer,𝓟1054{context}.entityIdForValue(𝓟1053{value})))
{
𝓟1054{context}.entityTransformer(𝓟1056{newValue})
}
return 𝓟1055 = 𝓟1056{newValue}
}
return 𝓟1055 = 𝓟1053{value}
}
function 𝓟1057{_visitSelection} (𝓟1058{query}: [OOV]𝓟[ty]791{OperationInstance},𝓟1059{context}: 𝓟[ty]406{CacheContext},𝓟1060{result}: [OOV]𝓟[ty]506{NestedObject},𝓟1061{includeNodeIds}: (𝓟[ty]1322{OperationWalkNode} ≠ 𝓛[ty]8666{Boolean})): (𝓟1062: 𝓛[ty]8642{Object})
{
let 𝓟1063{complete}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
let 𝓟1064{nodeIds}: [OOV]any;
if (𝓟1061{includeNodeIds})
{
𝓟1064{nodeIds} ⟵ 𝓛2997{Set}.CONSTRUCTOR();
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟1060{result},𝓛12643{undefined}))
{
𝓟1064{nodeIds}.add(𝓟1058{query}.rootId)
}
}
function 𝓟1065{$Lambda13} (𝓟1066{value},𝓟1067{fields}): (𝓟1068: [miss]𝓛[ty]8666{Boolean})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1066{value},𝓛12643{undefined}))
{
𝓟1063{complete} ⟵ 𝓛8744{Boolean};
}
if (𝓛12569{ExclamationToken}(𝓟1063{complete}))
{
return 𝓟1068 = 𝓛12569{ExclamationToken}(𝓟1061{includeNodeIds})
}
if (𝓛12569{ExclamationToken}(𝓟235{isObject}(𝓟1066{value})))
{
return 𝓟1068 = 𝓛8744{Boolean}
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟1064{nodeIds},𝓟235{isObject}(𝓟1066{value})))
{
const 𝓟1069{nodeId}: [miss]𝓛[ty]10051{String} = 𝓟1059{context}.entityIdForValue(𝓟1066{value});
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟1069{nodeId},𝓛12643{undefined}))
{
𝓟1064{nodeIds}.add(𝓟1069{nodeId})
}
}
{
const 𝓟1070{field}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1067{fields});
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟1070{field},𝓟1066{value})))
{
𝓟1063{complete} ⟵ 𝓛8744{Boolean};
}
}
}
return 𝓟1068 = 𝓛8744{Boolean}
}
𝓟1326{walkOperation}(𝓟1058{query}.info.parsed,𝓟1060{result},𝓟1065{$Lambda13})
return 𝓟1062 = {complete: 𝓟1063{complete},nodeIds: 𝓟1064{nodeIds}}
}
Module: src/ParsedQueryNode
type 𝓟[ty]1071{ParsedQueryNodeWithArgs} extends 𝓟[ty]1085{ParsedQueryNode} = {args: 𝓟[ty]506{NestedObject}}
type 𝓟[ty]506{NestedObject} = 𝓟[ty]506{NestedObject}
type 𝓟[ty]1073{ParsedQueryNodeMap} = {access: (𝓛[ty]10051{String})->𝓟[ty]1085{ParsedQueryNode}}
type 𝓟[ty]1074{JsonAndVariables} = any
type 𝓟[ty]1076{ParsedQuery} = 𝓟[ty]1073{ParsedQueryNodeMap}
type 𝓟[ty]1073{ParsedQueryNodeMap} = 𝓟[ty]1073{ParsedQueryNodeMap}
function 𝓟1077{CONSTRUCTOR} (𝓟1078{children}: [OOV]𝓟[ty]1073{ParsedQueryNodeMap},𝓟1079{schemaName}: 𝓛[ty]10051{String},𝓟1080{args}: [OOV]𝓟[ty]506{NestedObject},𝓟1081{hasParameterizedChildren}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8666{Boolean})): (𝓟[ty]1085{ParsedQueryNode})
{
const 𝓟[ty]1085{ParsedQueryNode};
const 𝓟[ty]1085{ParsedQueryNode};
𝓟[ty]1085{ParsedQueryNode}.schemaName ⟵ 𝓟1079{schemaName};
𝓟[ty]1085{ParsedQueryNode}.children ⟵ 𝓟1078{children};
𝓟[ty]1085{ParsedQueryNode}.hasParameterizedChildren ⟵ 𝓟1081{hasParameterizedChildren};
𝓟[ty]1085{ParsedQueryNode}.args ⟵ 𝓟1080{args};
}
class 𝓟[ty]1085{ParsedQueryNode}{
𝓟1087{children}: [OOV]𝓟[ty]1073{ParsedQueryNodeMap};
𝓟1088{schemaName}: 𝓛[ty]10051{String};
𝓟1089{args}: [OOV]𝓟[ty]506{NestedObject};
𝓟1090{hasParameterizedChildren}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8666{Boolean});
}
function 𝓟1091{CONSTRUCTOR} (𝓟1092{name}: 𝓛[ty]10051{String}): (𝓟[ty]1096{VariableArgument})
{
const 𝓟[ty]1096{VariableArgument};
const 𝓟[ty]1096{VariableArgument};
𝓟[ty]1096{VariableArgument}.name ⟵ 𝓟1092{name};
}
class 𝓟[ty]1096{VariableArgument}{
𝓟1098{name}: 𝓛[ty]10051{String};
}
function 𝓟1099{parseQuery} (𝓟1100{context}: 𝓟[ty]406{CacheContext},𝓟1101{fragments}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟1102{selectionSet}: [OOV]𝓛[ty]22940{SelectionSetNode}): (𝓟1103: 𝓛[ty]8642{Object})
{
const 𝓟1104{variables}: [miss]𝓛[ty]5956{Set} = 𝓛2997{Set}.CONSTRUCTOR();
const 𝓟1105{parsedQuery}: [OOV]𝓟[ty]1076{ParsedQuery} = 𝓟1106{_buildNodeMap}(𝓟1104{variables},𝓟1100{context},𝓟1101{fragments},𝓟1102{selectionSet});
if (𝓛12569{ExclamationToken}(𝓟1105{parsedQuery}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
return 𝓟1103 = {parsedQuery: 𝓟1105{parsedQuery},variables: 𝓟1104{variables}}
}
function 𝓟1106{_buildNodeMap} (𝓟1107{variables}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]5956{Set}),𝓟1108{context}: 𝓟[ty]406{CacheContext},𝓟1109{fragments}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟1110{selectionSet}: [OOV]𝓛[ty]22940{SelectionSetNode},𝓟1111{path}: 𝓛[ty]8670{Array}): (𝓟1112: [OOV]any)
{
if (𝓛12569{ExclamationToken}(𝓟1110{selectionSet}))
{
return 𝓟1112 = 𝓛12643{undefined}
}
const 𝓟1113{nodeMap} = 𝓛8741{Object}.create(𝓛12643{undefined});
{
const 𝓟1114{selection} = 𝓛12589{$ArrayAccess}(𝓟1110{selectionSet}.selections);
while (𝓛8744{Boolean})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1114{selection}.kind,𝓛8743{String}))
{
const 𝓟1115{name} = (𝓟1114{selection}.alias ? 𝓟1114{selection}.alias.value : 𝓟1114{selection}.name.value;
const 𝓟1116{children}: [OOV]𝓟[ty]1076{ParsedQuery} = 𝓟1106{_buildNodeMap}(𝓟1107{variables},𝓟1108{context},𝓟1109{fragments},𝓟1114{selection}.selectionSet,𝓛8757{Array}(𝓛12587{$Spread}(𝓟1111{path}),𝓟1115{name}));
let 𝓟1117{args};
let 𝓟1118{schemaName};
if (𝓛12569{ExclamationToken}(𝓟782{fieldHasStaticDirective}(𝓟1114{selection})))
{
𝓟1117{args} ⟵ 𝓟1129{_buildFieldArgs}(𝓟1107{variables},𝓟1114{selection}.arguments);
𝓟1118{schemaName} ⟵ (𝓟1114{selection}.alias ? 𝓟1114{selection}.name.value : 𝓛12643{undefined};
}
const 𝓟1119{hasParameterizedChildren}: [miss]𝓛[ty]8666{Boolean} = 𝓟1124{areChildrenDynamic}(𝓟1116{children});
const 𝓟1120{node}: [miss]𝓟[ty]1085{ParsedQueryNode} = 𝓟1077{CONSTRUCTOR}(𝓟1116{children},𝓟1118{schemaName},𝓟1117{args},𝓟1119{hasParameterizedChildren});
𝓟1113{nodeMap}.access(𝓟1115{name}) ⟵ 𝓟1152{_mergeNodes}(𝓛8757{Array}(𝓛12587{$Spread}(𝓟1111{path}),𝓟1115{name}),𝓟1120{node},𝓟1113{nodeMap}.access(𝓟1115{name}));
}
else
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1114{selection}.kind,𝓛8743{String}))
{
const 𝓟1121{fragment} = 𝓟1109{fragments}.access(𝓟1114{selection}.name.value);
if (𝓛12569{ExclamationToken}(𝓟1121{fragment}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓟1114{selection}.name.value))
}
const 𝓟1122{fragmentMap}: [OOV]𝓟[ty]1076{ParsedQuery} = 𝓟1106{_buildNodeMap}(𝓟1107{variables},𝓟1108{context},𝓟1109{fragments},𝓟1121{fragment}.selectionSet,𝓟1111{path});
if (𝓟1122{fragmentMap})
{
{
const 𝓟1123{name}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1122{fragmentMap});
while (𝓛8744{Boolean})
{
𝓟1113{nodeMap}.access(𝓟1123{name}) ⟵ 𝓟1152{_mergeNodes}(𝓛8757{Array}(𝓛12587{$Spread}(𝓟1111{path}),𝓟1123{name}),𝓟1122{fragmentMap}.access(𝓟1123{name}),𝓟1113{nodeMap}.access(𝓟1123{name}));
}
}
}
}
else
{
if (𝓟1108{context}.tracer.warning)
{
𝓟1108{context}.tracer.warning(𝓛12607{$Template}(𝓟1114{selection}.kind))
}
}
}
𝓟1142{_collectDirectiveVariables}(𝓟1107{variables},𝓟1114{selection})
}
}
return 𝓟1112 = (𝓛8741{Object}.keys(𝓟1113{nodeMap}).length ? 𝓟1113{nodeMap} : 𝓛12643{undefined}
}
function 𝓟1124{areChildrenDynamic} (𝓟1125{children}: [OOV]𝓟[ty]1076{ParsedQuery}): (𝓟1126: [miss]𝓛[ty]8666{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟1125{children}))
{
return 𝓟1126 = 𝓛12643{undefined}
}
{
const 𝓟1127{name}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1125{children});
while (𝓛8744{Boolean})
{
const 𝓟1128{child}: [miss]𝓟[ty]1085{ParsedQueryNode} = 𝓟1125{children}.access(𝓟1127{name});
if (𝓟1128{child}.hasParameterizedChildren)
{
return 𝓟1126 = 𝓛8744{Boolean}
}
if (𝓟1128{child}.args)
{
return 𝓟1126 = 𝓛8744{Boolean}
}
if (𝓟1128{child}.schemaName)
{
return 𝓟1126 = 𝓛8744{Boolean}
}
}
}
return 𝓟1126 = 𝓛12643{undefined}
}
function 𝓟1129{_buildFieldArgs} (𝓟1130{variables}: (𝓛[ty]10051{String} ≠ 𝓛[ty]5956{Set}),𝓟1131{argumentsNode}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array})): (𝓟1132: [miss]𝓛[ty]8642{Object})
{
if (𝓛12569{ExclamationToken}(𝓟1131{argumentsNode}))
{
return 𝓟1132 = 𝓛12643{undefined}
}
const 𝓟1133{args}: [miss]𝓛[ty]8642{Object} = {};
{
const 𝓟1134{arg} = 𝓛12589{$ArrayAccess}(𝓟1131{argumentsNode});
while (𝓛8744{Boolean})
{
𝓟1133{args}.access(𝓟1134{arg}.name.value) ⟵ 𝓟1135{_valueFromNode}(𝓟1130{variables},𝓟1134{arg}.value);
}
}
return 𝓟1132 = (𝓛8741{Object}.keys(𝓟1133{args}).length ? 𝓟1133{args} : 𝓛12643{undefined}
}
function 𝓟1135{_valueFromNode} (𝓟1136{variables}: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓛[ty]5956{Set}),𝓟1137{node}: [OOV]𝓛[ty]22948{ValueNode}): (𝓟1138: [OOV]𝓟[ty]513{NestedValue})
{
function 𝓟1139{$Lambda5} (𝓟1140{_}): (𝓟1141: [miss]𝓟[ty]1096{VariableArgument})
{
}
return 𝓟1138 = 𝓟1517{valueFromNode}(𝓟1137{node},𝓟1139{$Lambda5})
}
function 𝓟1142{_collectDirectiveVariables} (𝓟1143{variables}: (𝓛[ty]10051{String} ≠ 𝓛[ty]5956{Set}),𝓟1144{node}: [OOV]𝓛[ty]22951{SelectionNode}): (𝓟1145: [miss]𝓛[ty]10033{Void})
{
const 𝓟1146{directives} = 𝓟1144{node}.directives;
if (𝓛12569{ExclamationToken}(𝓟1146{directives}))
{
}
{
const 𝓟1147{directive} = 𝓛12589{$ArrayAccess}(𝓟1146{directives});
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟1147{directive}.arguments))
{
}
{
const 𝓟1148{argument} = 𝓛12589{$ArrayAccess}(𝓟1147{directive}.arguments);
while (𝓛8744{Boolean})
{
function 𝓟1149{$Lambda6} (𝓟1150{_}): (𝓟1151: [miss]𝓛[ty]10033{Void})
{
}
𝓟1517{valueFromNode}(𝓟1148{argument}.value,𝓟1149{$Lambda6})
}
}
}
}
}
function 𝓟1152{_mergeNodes} (𝓟1153{path}: 𝓛[ty]8670{Array},𝓟1154{target}: 𝓟[ty]1085{ParsedQueryNode},𝓟1155{source}: 𝓟[ty]1085{ParsedQueryNode}): (𝓟1156: [miss]𝓟[ty]1085{ParsedQueryNode})
{
if (𝓛12569{ExclamationToken}(𝓟1155{source}))
{
return 𝓟1156 = 𝓟1154{target}
}
if (𝓛12569{ExclamationToken}(𝓟1513{isEqual}(𝓟1154{target}.args,𝓟1155{source}.args)))
{
𝓟287{CONSTRUCTOR}(𝓛8743{String},𝓟1153{path},𝓛8757{Array}(𝓟1154{target},𝓟1155{source}))
}
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟1154{target}.schemaName,𝓟1155{source}.schemaName))
{
𝓟287{CONSTRUCTOR}(𝓛8743{String},𝓟1153{path},𝓛8757{Array}(𝓟1154{target},𝓟1155{source}))
}
if (𝓛12569{ExclamationToken}(𝓟1155{source}.children))
{
return 𝓟1156 = 𝓟1154{target}
}
if (𝓛12569{ExclamationToken}(𝓟1154{target}.children))
{
𝓟1154{target}.children ⟵ 𝓟1155{source}.children;
}
else
{
{
const 𝓟1157{name}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1155{source}.children);
while (𝓛8744{Boolean})
{
𝓟1154{target}.children.access(𝓟1157{name}) ⟵ 𝓟1152{_mergeNodes}(𝓛8757{Array}(𝓛12587{$Spread}(𝓟1153{path}),𝓟1157{name}),𝓟1155{source}.children.access(𝓟1157{name}),𝓟1154{target}.children.access(𝓟1157{name}));
}
}
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟1155{source}.hasParameterizedChildren,𝓛12569{ExclamationToken}(𝓟1154{target}.hasParameterizedChildren)))
{
𝓟1154{target}.hasParameterizedChildren ⟵ 𝓛8744{Boolean};
}
return 𝓟1156 = 𝓟1154{target}
}
function 𝓟1158{expandVariables} (𝓟1159{parsed}: [OOV]𝓟[ty]1076{ParsedQuery},𝓟1160{variables}: [OOV]any): (𝓟1161: [OOV]𝓟[ty]1073{ParsedQueryNodeMap})
{
return 𝓟1161 = 𝓟1162{_expandVariables}(𝓟1159{parsed},𝓟1160{variables})
}
function 𝓟1162{_expandVariables} (𝓟1163{parsed}: [OOV]𝓟[ty]1076{ParsedQuery},𝓟1164{variables}: [OOV]𝓟[ty]506{NestedObject}): (𝓟1165: [miss]𝓛[ty]8642{Object})
{
if (𝓛12569{ExclamationToken}(𝓟1163{parsed}))
{
return 𝓟1165 = 𝓛12643{undefined}
}
const 𝓟1166{newMap}: [miss]𝓛[ty]8642{Object} = {};
{
const 𝓟1167{key}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1163{parsed});
while (𝓛8744{Boolean})
{
const 𝓟1168{node}: [miss]𝓟[ty]1085{ParsedQueryNode} = 𝓟1163{parsed}.access(𝓟1167{key});
if (𝓛12546{BarBarToken}(𝓟1168{node}.args,𝓟1168{node}.hasParameterizedChildren))
{
𝓟1166{newMap}.access(𝓟1167{key}) ⟵ 𝓟1077{CONSTRUCTOR}(𝓟1162{_expandVariables}(𝓟1168{node}.children,𝓟1164{variables}),𝓟1168{node}.schemaName,𝓟1169{expandFieldArguments}(𝓟1168{node}.args,𝓟1164{variables}),𝓟1168{node}.hasParameterizedChildren);
}
else
{
𝓟1166{newMap}.access(𝓟1167{key}) ⟵ 𝓟1168{node};
}
}
}
return 𝓟1165 = 𝓟1166{newMap}
}
function 𝓟1169{expandFieldArguments} (𝓟1170{args}: [OOV]any,𝓟1171{variables}: [OOV]any): (𝓟1172: [OOV]any)
{
return 𝓟1172 = (𝓟1170{args} ? 𝓟1173{_expandArgument}(𝓟1170{args},𝓟1171{variables}) as 𝓟[ty]506{NestedObject} : 𝓛12643{undefined}
}
function 𝓟1173{_expandArgument} (𝓟1174{arg}: [OOV]𝓟[ty]513{NestedValue},𝓟1175{variables}: [OOV]any): (𝓟1176: [OOV]𝓟[ty]513{NestedValue})
{
if (𝓛1{<UNKNOWN>}(𝓟1174{arg},𝓛12643{undefined}))
{
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟1175{variables}),𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟1174{arg}.name,𝓟1175{variables}))))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓟1174{arg}.name))
}
return 𝓟1176 = 𝓟1175{variables}.access(𝓟1174{arg}.name)
}
else
{
if (𝓛8757{Array}.isArray(𝓟1174{arg}))
{
function 𝓟1177{$Lambda7} (𝓟1178{v}): (𝓟1179: [OOV]𝓟[ty]513{NestedValue})
{
return 𝓟1179 = 𝓟1173{_expandArgument}(𝓟1178{v},𝓟1175{variables})
}
return 𝓟1176 = 𝓟1174{arg}.map(𝓟1177{$Lambda7})
}
else
{
if (𝓟235{isObject}(𝓟1174{arg}))
{
const 𝓟1180{expanded}: [miss]𝓛[ty]8642{Object} = {};
{
const 𝓟1181{key}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1174{arg});
while (𝓛8744{Boolean})
{
𝓟1180{expanded}.access(𝓟1181{key}) ⟵ 𝓟1173{_expandArgument}(𝓟1174{arg}.access(𝓟1181{key}),𝓟1175{variables});
}
}
return 𝓟1176 = 𝓟1180{expanded}
}
else
{
return 𝓟1176 = 𝓟1174{arg} as 𝓟[ty]513{NestedValue}
}
}
}
}
Module: src/context/QueryInfo
function 𝓟1209{CONSTRUCTOR} (𝓟1210{context}: 𝓟[ty]406{CacheContext},𝓟1211{raw}: [OOV]𝓟[ty]787{RawOperation}): (𝓟[ty]1217{QueryInfo})
{
const 𝓟[ty]1217{QueryInfo};
const 𝓟[ty]1217{QueryInfo};
𝓟[ty]1217{QueryInfo}.document ⟵ 𝓟1211{raw}.document;
𝓟[ty]1217{QueryInfo}.operation ⟵ 𝓟1523{getOperationOrDie}(𝓟1211{raw}.document);
𝓟[ty]1217{QueryInfo}.operationType ⟵ 𝓟[ty]1217{QueryInfo}.operation.operation;
𝓟[ty]1217{QueryInfo}.operationName ⟵ 𝓛12592{AmpersandAmpersandToken}(𝓟[ty]1217{QueryInfo}.operation.name,𝓟[ty]1217{QueryInfo}.operation.name.value);
𝓟[ty]1217{QueryInfo}.operationSource ⟵ 𝓛12592{AmpersandAmpersandToken}(𝓟[ty]1217{QueryInfo}.operation.loc,𝓟[ty]1217{QueryInfo}.operation.loc.source.body);
𝓟[ty]1217{QueryInfo}.fragmentMap ⟵ 𝓟761{fragmentMapForDocument}(𝓟1211{raw}.document);
const 𝓟1215{parsedQuery}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1099{parseQuery}(𝓟1210{context},𝓟[ty]1217{QueryInfo}.fragmentMap,𝓟[ty]1217{QueryInfo}.operation.selectionSet).parsedQuery;
const 𝓟1216{variables}: [miss]𝓛[ty]5956{Set} = 𝓟1099{parseQuery}(𝓟1210{context},𝓟[ty]1217{QueryInfo}.fragmentMap,𝓟[ty]1217{QueryInfo}.operation.selectionSet).variables;
𝓟[ty]1217{QueryInfo}.parsed ⟵ 𝓟1215{parsedQuery};
𝓟[ty]1217{QueryInfo}.variables ⟵ 𝓟1216{variables};
𝓟[ty]1217{QueryInfo}.variableDefaults ⟵ 𝓟755{variableDefaultsInOperation}(𝓟[ty]1217{QueryInfo}.operation);
if (𝓛12569{ExclamationToken}(𝓟1211{raw}.fromFragmentDocument))
{
𝓟[ty]1217{QueryInfo}._assertValid()
}
}
class 𝓟[ty]1217{QueryInfo}{
𝓟1219{variableDefaults}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8642{Object});
𝓟1220{document}: [OOV]𝓛[ty]22936{DocumentNode};
𝓟1221{operationType}: [OOV]𝓛[ty]22947{OperationTypeNode};
𝓟1222{parsed}: [OOV]𝓟[ty]1076{ParsedQuery};
𝓟1223{variables}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]5956{Set});
𝓟1224{fragmentMap}: [OOV]𝓛[ty]2{<UNKNOWN>};
𝓟1225{operation}: [OOV]𝓛[ty]22943{OperationDefinitionNode};
𝓟1226{operationName}: 𝓛[ty]10051{String};
𝓟1227{operationSource}: (𝓟[ty]307{OperationError} ≠ 𝓛[ty]10051{String});
function 𝓟1228{_assertValid} (): (𝓟1229: [miss]𝓛[ty]10033{Void})
{
const 𝓟1230{messages}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
const 𝓟1231{declaredVariables} = 𝓟1524{variablesInOperation}(𝓟[ty]1217{QueryInfo}.operation);
𝓟[ty]1217{QueryInfo}._assertAllVariablesDeclared(𝓟1230{messages},𝓟1231{declaredVariables})
𝓟[ty]1217{QueryInfo}._assertAllVariablesUsed(𝓟1230{messages},𝓟1231{declaredVariables})
if (𝓛12569{ExclamationToken}(𝓟1230{messages}.length))
{
}
const 𝓟1232{mainMessage}: [miss]𝓛[ty]10051{String} = 𝓛12607{$Template}(𝓟[ty]1217{QueryInfo}.operationType,𝓛12546{BarBarToken}(𝓟[ty]1217{QueryInfo}.operationName,𝓛8743{String}));
function 𝓟1233{$Lambda12} (𝓟1234{m}): (𝓟1235: [miss]𝓛[ty]10051{String})
{
return 𝓟1235 = 𝓛12607{$Template}(𝓟1234{m})
}
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓟1232{mainMessage},𝓟1230{messages}.map(𝓟1233{$Lambda12}).join(𝓛8743{String})))
}
function 𝓟1236{_assertAllVariablesDeclared} (𝓟1237{messages}: 𝓛[ty]8670{Array},𝓟1238{declaredVariables}: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓛[ty]5956{Set})): (𝓟1239: [miss]𝓛[ty]10033{Void})
{
{
const 𝓟1240{name}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟[ty]1217{QueryInfo}.variables);
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟1238{declaredVariables}.has(𝓟1240{name})))
{
𝓟1237{messages}.push(𝓛12607{$Template}(𝓟1240{name}))
}
}
}
}
function 𝓟1241{_assertAllVariablesUsed} (𝓟1242{messages}: 𝓛[ty]8670{Array},𝓟1243{declaredVariables}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]5956{Set})): (𝓟1244: [miss]𝓛[ty]10033{Void})
{
{
const 𝓟1245{name}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1243{declaredVariables});
while (𝓛8744{Boolean})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]1217{QueryInfo}.variables.has(𝓟1245{name})))
{
𝓟1242{messages}.push(𝓛12607{$Template}(𝓟1245{name}))
}
}
}
}
}
Module: src/context/ConsoleTracer
const 𝓟1246{INDENT}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟1247{CONSTRUCTOR} (𝓟1248{_verbose}: (𝓟[ty]406{CacheContext} ≠ 𝓛[ty]8666{Boolean}),𝓟1249{_logger}: [OOV]𝓟[ty]1301{Logger}): (𝓟[ty]1253{ConsoleTracer})
{
const 𝓟[ty]1253{ConsoleTracer};
const 𝓟[ty]1253{ConsoleTracer};
𝓟[ty]1253{ConsoleTracer}._indent ⟵ 𝓛8745{Number};
}
class 𝓟[ty]1253{ConsoleTracer} extends 𝓟[ty]816{Tracer}{
𝓟1255{_indent}: [miss]𝓛[ty]8655{Number};
function 𝓟1265{writeEnd} (𝓟1266{operation}: [OOV]𝓟[ty]791{OperationInstance},𝓟1267{info}: [OOV]𝓟[ty]817{WriteInfo}): (𝓟1268: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]1253{ConsoleTracer}._verbose))
{
}
const 𝓟1269{payload}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1267{info}.payload;
const 𝓟1270{newSnapshot}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1267{info}.newSnapshot;
const 𝓟1271{warnings}: [miss]𝓛[ty]8670{Array} = 𝓟1267{info}.warnings;
const 𝓟1272{message}: [miss]𝓛[ty]10051{String} = 𝓟[ty]1253{ConsoleTracer}.formatOperation(𝓛8743{String},𝓟1266{operation});
if (𝓟1271{warnings})
{
function 𝓟1273{$Lambda10} (): (𝓟1274: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]1253{ConsoleTracer}._emit(𝓛8743{String},𝓛8743{String},𝓟1269{payload})
{
const 𝓟1275{warning}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1271{warnings});
while (𝓛8744{Boolean})
{
𝓟[ty]1253{ConsoleTracer}._emit(𝓛8743{String},𝓟1275{warning})
}
}
𝓟[ty]1253{ConsoleTracer}._emit(𝓛8743{String},𝓛8743{String},𝓟1270{newSnapshot})
}
𝓟[ty]1253{ConsoleTracer}._group(𝓟1272{message},𝓟1273{$Lambda10})
}
else
{
𝓟[ty]1253{ConsoleTracer}._emit(𝓛8743{String},𝓟1272{message},{payload: 𝓟1269{payload},newSnapshot: 𝓟1270{newSnapshot}})
}
}
function 𝓟1298{_groupEnd} (): (𝓟1299: [miss]𝓛[ty]10033{Void})
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟[ty]1253{ConsoleTracer}._logger.group,𝓟[ty]1253{ConsoleTracer}._logger.groupEnd))
{
𝓟[ty]1253{ConsoleTracer}._logger.groupEnd()
}
else
{
𝓛12606{MinusEqualsToken}(𝓟[ty]1253{ConsoleTracer}._indent,𝓛8745{Number})
}
}
function 𝓟1256{warning} (𝓟1257{message}: 𝓛[ty]10051{String},𝓟1258{metadata}: 𝓛[ty]8670{Array}): (𝓟1259: [miss]𝓛[ty]10033{Void})
{
if (𝓟[ty]1253{ConsoleTracer}._verbose)
{
}
𝓟[ty]1253{ConsoleTracer}._emit(𝓛8743{String},𝓟1257{message},𝓛12587{$Spread}(𝓟1258{metadata}))
}
function 𝓟1295{_groupStart} (𝓟1296{message}: 𝓛[ty]10051{String}): (𝓟1297: [miss]𝓛[ty]10033{Void})
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟[ty]1253{ConsoleTracer}._logger.group,𝓟[ty]1253{ConsoleTracer}._logger.groupEnd))
{
𝓟[ty]1253{ConsoleTracer}._logger.group(𝓟1296{message})
}
else
{
𝓛12564{FirstCompoundAssignment}(𝓟[ty]1253{ConsoleTracer}._indent,𝓛8745{Number})
𝓟[ty]1253{ConsoleTracer}._logger.info(𝓟1296{message})
}
}
function 𝓟1276{transactionEnd} (𝓟1277{error}: [OOV]any): (𝓟1278: [miss]𝓛[ty]10033{Void})
{
if (𝓟1277{error})
{
𝓟[ty]1253{ConsoleTracer}._emit(𝓛8743{String},𝓛8743{String},𝓟1277{error})
}
}
function 𝓟1291{_group} (𝓟1292{message}: 𝓛[ty]10051{String},𝓟1293{callback}: 𝓛[ty]8696{Function}): (𝓟1294: [miss]𝓛[ty]10033{Void})
{
𝓟[ty]1253{ConsoleTracer}._groupStart(𝓟1292{message})
{
𝓟1293{callback}()
}
{
𝓟[ty]1253{ConsoleTracer}._groupEnd()
}
}
function 𝓟1279{formatOperation} (𝓟1280{action}: 𝓛[ty]10051{String},𝓟1281{operation}: [OOV]𝓟[ty]791{OperationInstance}): (𝓟1282: [miss]𝓛[ty]10051{String})
{
const 𝓟1283{operationType} = 𝓟1281{operation}.info.operationType;
const 𝓟1284{operationName}: [miss]𝓛[ty]10051{String} = 𝓟1281{operation}.info.operationName;
return 𝓟1282 = 𝓛12607{$Template}(𝓟1280{action},𝓟1283{operationType},𝓟1284{operationName})
}
function 𝓟1285{_emit} (𝓟1286{level}: [OOV]any,𝓟1287{message}: 𝓛[ty]10051{String},𝓟1288{metadata}: 𝓛[ty]8670{Array}): (𝓟1289: [miss]𝓛[ty]10033{Void})
{
if (𝓟[ty]1253{ConsoleTracer}._indent)
{
{
let 𝓟1290{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
while (𝓛1{<UNKNOWN>}(𝓟1290{i},𝓟[ty]1253{ConsoleTracer}._indent))
{
{
𝓟1287{message} ⟵ 𝓛12607{$Template}(𝓟1246{INDENT},𝓟1287{message});
}
𝓛12556{POST_PlusPlusToken}(𝓟1290{i})
}
}
}
𝓟[ty]1253{ConsoleTracer}._logger.access(𝓟1286{level})(𝓟1287{message},𝓛12587{$Spread}(𝓟1288{metadata}))
}
function 𝓟1260{readEnd} (𝓟1261{operation}: [OOV]𝓟[ty]791{OperationInstance},𝓟1262{info}: [OOV]𝓟[ty]818{ReadInfo}): (𝓟1263: [miss]𝓛[ty]10033{Void})
{
if (𝓛12569{ExclamationToken}(𝓟[ty]1253{ConsoleTracer}._verbose))
{
}
const 𝓟1264{message}: [miss]𝓛[ty]10051{String} = 𝓟[ty]1253{ConsoleTracer}.formatOperation(𝓛8743{String},𝓟1261{operation});
if (𝓟1262{info}.cacheHit)
{
𝓟[ty]1253{ConsoleTracer}._emit(𝓛8743{String},𝓛12607{$Template}(𝓟1264{message}),𝓟1262{info}.result)
}
else
{
𝓟[ty]1253{ConsoleTracer}._emit(𝓛8743{String},𝓟1264{message},𝓟1262{info}.result)
}
}
}
type 𝓟[ty]1300{LogEmitter} = (𝓛[ty]10051{String},𝓛[ty]8670{Array})->𝓛[ty]10033{Void}
type 𝓟[ty]1301{Logger} = {warn: 𝓟[ty]1300{LogEmitter}, info: 𝓟[ty]1300{LogEmitter}, debug: 𝓟[ty]1300{LogEmitter}, group: 𝓟[ty]1300{LogEmitter}, groupEnd: ()->𝓛[ty]10033{Void}}
function 𝓟1302{$Lambda11} (): (𝓟1303: [miss]𝓛[ty]10033{Void})
{
}
const 𝓟1304{DefaultLogger}: [OOV]𝓟[ty]1301{Logger} = {warn: 𝓟1305{_makeDefaultEmitter}(𝓛8743{String}),info: 𝓟1305{_makeDefaultEmitter}(𝓛8743{String}),debug: 𝓟1305{_makeDefaultEmitter}(𝓛8743{String}),group: 𝓟1305{_makeDefaultEmitter}(𝓛8743{String}),groupEnd: (𝓛1{<UNKNOWN>} ? 𝓛1{<UNKNOWN>}.bind(𝓛12353{console}) : 𝓟1302{$Lambda11}};
function 𝓟1305{_makeDefaultEmitter} (𝓟1306{level}: [OOV]any): (𝓟1307: [miss]𝓛[ty]8696{Function})
{
const 𝓟1308{method}: [miss]𝓛[ty]8696{Function} = 𝓛12546{BarBarToken}(𝓛1{<UNKNOWN>}(𝓟1306{level}),𝓛1{<UNKNOWN>});
function 𝓟1309{defaultLogger} (𝓟1310{message}: 𝓛[ty]10051{String},𝓟1311{args}: 𝓛[ty]8670{Array}): (𝓟1312: [miss]𝓛[ty]10033{Void})
{
𝓟1308{method}.call(𝓛12353{console},𝓛12607{$Template}(𝓟1310{message}),𝓛12587{$Spread}(𝓟1311{args}))
}
return 𝓟1307 = 𝓟1309{defaultLogger}
}
Module: src/nodes/NodeSnapshot
type 𝓟[ty]1313{NodeReference} = {id: 𝓛[ty]10051{String}, path: 𝓛[ty]8670{Array}}
type 𝓟[ty]1314{NodeSnapshot} = {data: 𝓟[ty]513{NestedValue}, inbound: 𝓛[ty]8670{Array}, outbound: 𝓛[ty]8670{Array}}
Module: src/util/tree
type 𝓟[ty]1315{OperationVisitor} = (any,𝓛[ty]8670{Array})->𝓛[ty]8666{Boolean}
function 𝓟1316{CONSTRUCTOR} (𝓟1317{parsedOperation}: [OOV]𝓟[ty]1076{ParsedQuery},𝓟1318{parent}: [OOV]𝓟[ty]513{NestedValue}): (𝓟[ty]1322{OperationWalkNode})
{
const 𝓟[ty]1322{OperationWalkNode};
const 𝓟[ty]1322{OperationWalkNode};
𝓟[ty]1322{OperationWalkNode}.parsedOperation ⟵ 𝓟1317{parsedOperation};
𝓟[ty]1322{OperationWalkNode}.parent ⟵ 𝓟1318{parent};
}
class 𝓟[ty]1322{OperationWalkNode}{
𝓟1324{parsedOperation}: [OOV]𝓟[ty]1076{ParsedQuery};
𝓟1325{parent}: [OOV]𝓟[ty]513{NestedValue};
}
function 𝓟1326{walkOperation} (𝓟1327{rootOperation}: [OOV]𝓟[ty]1076{ParsedQuery},𝓟1328{result}: [OOV]any,𝓟1329{visitor}: [OOV]𝓟[ty]1315{OperationVisitor}): (𝓟1330: [miss]𝓛[ty]10033{Void})
{
const 𝓟1331{stack}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓟1316{CONSTRUCTOR}(𝓟1327{rootOperation},𝓟1328{result}));
while (𝓟1331{stack}.length)
{
const 𝓟1332{parsedOperation}: [OOV]𝓟[ty]1076{ParsedQuery} = 𝓟1331{stack}.pop().parsedOperation;
const 𝓟1333{parent}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1331{stack}.pop().parent;
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1333{parent},𝓛12643{undefined}))
{
}
if (𝓛8757{Array}.isArray(𝓟1333{parent}))
{
{
let 𝓟1334{i}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟1333{parent}.length,𝓛8745{Number});
while (𝓛12596{GreaterThanEqualsToken}(𝓟1334{i},𝓛8745{Number}))
{
{
𝓟1331{stack}.push(𝓟1316{CONSTRUCTOR}(𝓟1332{parsedOperation},𝓟1333{parent}.access(𝓟1334{i})))
}
𝓛12614{POST_MinusMinusToken}(𝓟1334{i})
}
}
}
const 𝓟1335{fields}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
{
const 𝓟1336{fieldName}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1332{parsedOperation});
while (𝓛8744{Boolean})
{
𝓟1335{fields}.push(𝓟1336{fieldName})
const 𝓟1337{nextParsedQuery}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1332{parsedOperation}.access(𝓟1336{fieldName}).children;
if (𝓟1337{nextParsedQuery})
{
𝓟1331{stack}.push(𝓟1316{CONSTRUCTOR}(𝓟1337{nextParsedQuery},𝓟1339{get}(𝓟1333{parent},𝓟1336{fieldName})))
}
}
}
if (𝓟1335{fields}.length)
{
const 𝓟1338{shouldStop}: [miss]𝓛[ty]8666{Boolean} = 𝓟1329{visitor}(𝓟1333{parent},𝓟1335{fields});
if (𝓟1338{shouldStop})
{
}
}
}
}
function 𝓟1339{get} (𝓟1340{value}: [OOV]any,𝓟1341{key}: [OOV]𝓟[ty]508{PathPart}): (𝓟1342: [OOV]any)
{
return 𝓟1342 = (𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟1340{value},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1340{value}),𝓛8743{String})) ? 𝓟1340{value}.access(𝓟1341{key}) : 𝓛12643{undefined}
}
Module: src/apollo/Transaction
function 𝓟1343{getOriginalFieldArguments} (𝓟1344{id}: 𝓛[ty]10051{String}): (𝓟1345: [OOV]any)
{
const 𝓟1346{idComponents}: [miss]𝓛[ty]8670{Array} = 𝓟1344{id}.split(𝓛8743{String});
if (𝓛1{<UNKNOWN>}(𝓟1346{idComponents}.length,𝓛8745{Number}))
{
return 𝓟1345 = 𝓛12643{undefined}
}
return 𝓟1345 = 𝓛8756{JSON}.parse(𝓟1346{idComponents}.access(𝓛8745{Number}))
}
function 𝓟1347{CONSTRUCTOR} (𝓟1348{_queryable}: (𝓟[ty]1410{Hermes} ≠ 𝓟[ty]681{CacheTransaction})): (𝓟[ty]1352{ApolloTransaction})
{
const 𝓟[ty]1352{ApolloTransaction};
const 𝓟[ty]1352{ApolloTransaction};
𝓟[ty]1352{ApolloTransaction}()
}
class 𝓟[ty]1352{ApolloTransaction} extends 𝓟[ty]936{ApolloQueryable} with 𝓛[ty]2{<UNKNOWN>}{
function 𝓟1369{restore} (): (𝓟1370: [OOV]any)
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟1366{watch} (𝓟1367{_query}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1368: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟1373{updateListOfReferences} (𝓟1374{containerId}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String}),𝓟1375{editPath}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟1376{_}: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓛[ty]8642{Object}),𝓟1377{_}: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓛[ty]8642{Object}),𝓟1378{updateFieldCallback}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1379: [miss]𝓛[ty]10033{Void})
{
}
function 𝓟1356{removeOptimistic} (𝓟1357{_id}: 𝓛[ty]10051{String}): (𝓟1358: 𝓛[ty]10033{Void})
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟1359{performTransaction} (𝓟1360{transaction}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1361: 𝓛[ty]10033{Void})
{
𝓟1360{transaction}(𝓟[ty]1352{ApolloTransaction})
}
function 𝓟1354{reset} (): (𝓟1355: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8654{Promise}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟1362{recordOptimisticTransaction} (𝓟1363{_transaction}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟1364{_id}: 𝓛[ty]10051{String}): (𝓟1365: 𝓛[ty]10033{Void})
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
function 𝓟1371{extract} (): (𝓟1372: [OOV]any)
{
𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
}
}
Module: src/context/index
Module: src/apollo/Hermes
function 𝓟1405{CONSTRUCTOR} (𝓟1406{configuration}: [OOV]𝓟[ty]399{Configuration}): (𝓟[ty]1410{Hermes})
{
const 𝓟[ty]1410{Hermes};
const 𝓟[ty]1410{Hermes};
𝓟[ty]1410{Hermes}()
𝓟[ty]1410{Hermes}._queryable ⟵ 𝓟821{CONSTRUCTOR}(𝓟1406{configuration});
}
class 𝓟[ty]1410{Hermes} extends 𝓟[ty]936{ApolloQueryable} with 𝓛[ty]2{<UNKNOWN>}{
𝓟1412{_queryable}: (𝓟[ty]1410{Hermes} ≠ 𝓟[ty]827{Cache});
function 𝓟1413{restore} (𝓟1414{data}: [OOV]any,𝓟1415{migrationMap}: [OOV]𝓟[ty]917{MigrationMap},𝓟1416{verifyOptions}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1417: [OOV]𝓛[ty]2{<UNKNOWN>})
{
const 𝓟1418{verifyQuery}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛12592{AmpersandAmpersandToken}(𝓟1416{verifyOptions},𝓟663{buildRawOperationFromQuery}(𝓟1416{verifyOptions}.query,𝓟1416{verifyOptions}.variables));
𝓟[ty]1410{Hermes}._queryable.restore(𝓟1414{data},𝓟1415{migrationMap},𝓟1418{verifyQuery})
return 𝓟1417 = 𝓟[ty]1410{Hermes}
}
function 𝓟1442{watch} (𝓟1443{options}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1444: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓛[ty]8696{Function}))
{
const 𝓟1445{query}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟663{buildRawOperationFromQuery}(𝓟1443{options}.query,𝓟1443{options}.variables,𝓟1443{options}.rootId);
return 𝓟1444 = 𝓟[ty]1410{Hermes}._queryable.watch(𝓟1445{query},𝓟1443{options}.callback)
}
function 𝓟1426{removeOptimistic} (𝓟1427{id}: 𝓛[ty]10051{String}): (𝓟1428: 𝓛[ty]10033{Void})
{
𝓟[ty]1410{Hermes}._queryable.rollback(𝓟1427{id})
}
function 𝓟1429{performTransaction} (𝓟1430{transaction}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1431: 𝓛[ty]10033{Void})
{
function 𝓟1432{$Lambda8} (𝓟1433{t}): (𝓟1434: [OOV]any)
{
return 𝓟1434 = 𝓟1430{transaction}(𝓟1347{CONSTRUCTOR}(𝓟1433{t}))
}
𝓟[ty]1410{Hermes}._queryable.transaction(𝓟1432{$Lambda8})
}
function 𝓟1424{reset} (): (𝓟1425: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓛[ty]8654{Promise}))
{
return 𝓟1425 = 𝓟[ty]1410{Hermes}._queryable.reset()
}
function 𝓟1435{recordOptimisticTransaction} (𝓟1436{transaction}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟1437{id}: 𝓛[ty]10051{String}): (𝓟1438: 𝓛[ty]10033{Void})
{
function 𝓟1439{$Lambda9} (𝓟1440{t}): (𝓟1441: [OOV]any)
{
return 𝓟1441 = 𝓟1436{transaction}(𝓟1347{CONSTRUCTOR}(𝓟1440{t}))
}
𝓟[ty]1410{Hermes}._queryable.transaction(𝓟1437{id},𝓟1439{$Lambda9})
}
function 𝓟1446{getCurrentCacheSnapshot} (): (𝓟1447: (𝓟[ty]1387{GraphSnapshot} ≠ 𝓟[ty]811{CacheSnapshot}))
{
return 𝓟1447 = 𝓟[ty]1410{Hermes}._queryable.getSnapshot()
}
function 𝓟1419{extract} (𝓟1420{optimistic}: (𝓟[ty]1188{OptimisticUpdateQueue} ≠ 𝓛[ty]8666{Boolean}),𝓟1421{pruneOptions}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1422: [OOV]any)
{
const 𝓟1423{pruneQuery}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛12592{AmpersandAmpersandToken}(𝓟1421{pruneOptions},𝓟663{buildRawOperationFromQuery}(𝓟1421{pruneOptions}.query,𝓟1421{pruneOptions}.variables));
return 𝓟1422 = 𝓟[ty]1410{Hermes}._queryable.extract(𝓟1420{optimistic},𝓟1423{pruneQuery})
}
}
Module: src/util/index
Module: src/operations/restore
function 𝓟1448{restore} (𝓟1449{serializedState}: [OOV]𝓟[ty]793{GraphSnapshot},𝓟1450{cacheContext}: 𝓟[ty]406{CacheContext}): (𝓟1451: [miss]𝓛[ty]8642{Object})
{
const 𝓟1452{nodesMap}: [OOV]𝓟[ty]1381{NodeSnapshotMap} = 𝓟1455{createGraphSnapshotNodes}(𝓟1449{serializedState},𝓟1450{cacheContext}).nodesMap;
const 𝓟1453{editedNodeIds}: [miss]𝓛[ty]5956{Set} = 𝓟1455{createGraphSnapshotNodes}(𝓟1449{serializedState},𝓟1450{cacheContext}).editedNodeIds;
const 𝓟1454{graphSnapshot}: [miss]𝓟[ty]1387{GraphSnapshot} = 𝓟1382{CONSTRUCTOR}(𝓟1452{nodesMap});
return 𝓟1451 = {cacheSnapshot: 𝓟804{CONSTRUCTOR}(𝓟1454{graphSnapshot},𝓟1454{graphSnapshot},𝓟1183{CONSTRUCTOR}()),editedNodeIds: 𝓟1453{editedNodeIds}}
}
function 𝓟1455{createGraphSnapshotNodes} (𝓟1456{serializedState}: [OOV]𝓟[ty]793{GraphSnapshot},𝓟1457{cacheContext}: 𝓟[ty]406{CacheContext}): (𝓟1458: [miss]𝓛[ty]8642{Object})
{
const 𝓟1459{nodesMap}: [OOV]𝓟[ty]1381{NodeSnapshotMap} = 𝓛8741{Object}.create(𝓛12643{undefined});
const 𝓟1460{editedNodeIds}: [miss]𝓛[ty]5956{Set} = 𝓛2997{Set}.CONSTRUCTOR();
{
const 𝓟1461{nodeId}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1456{serializedState});
while (𝓛8744{Boolean})
{
const 𝓟1462{type}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1456{serializedState}.access(𝓟1461{nodeId}).type;
const 𝓟1463{data}: [OOV]𝓟[ty]513{NestedValue} = 𝓟1456{serializedState}.access(𝓟1461{nodeId}).data;
const 𝓟1464{inbound}: [miss]𝓛[ty]8670{Array} = 𝓟1456{serializedState}.access(𝓟1461{nodeId}).inbound;
const 𝓟1465{outbound}: [miss]𝓛[ty]8670{Array} = 𝓟1456{serializedState}.access(𝓟1461{nodeId}).outbound;
let 𝓟1466{nodeSnapshot};
𝓛12577{$Switch}(𝓟1462{type})
𝓛12634{$Case}(𝓟796{NodeSnapshotType}.EntitySnapshot)
𝓟1466{nodeSnapshot} ⟵ 𝓟337{CONSTRUCTOR}(𝓟1463{data} as 𝓟[ty]506{NestedObject},𝓟1464{inbound},𝓟1465{outbound});
𝓛12634{$Case}(𝓟796{NodeSnapshotType}.ParameterizedValueSnapshot)
𝓟1466{nodeSnapshot} ⟵ 𝓟1486{CONSTRUCTOR}(𝓟1463{data} as 𝓟[ty]513{NestedValue},𝓟1464{inbound},𝓟1465{outbound});
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓟1462{type},𝓟1461{nodeId}))
𝓟1459{nodesMap}.access(𝓟1461{nodeId}) ⟵ 𝓟1466{nodeSnapshot};
𝓟1460{editedNodeIds}.add(𝓟1461{nodeId})
}
}
𝓟1467{restoreEntityReferences}(𝓟1459{nodesMap},𝓟1457{cacheContext})
return 𝓟1458 = {nodesMap: 𝓟1459{nodesMap},editedNodeIds: 𝓟1460{editedNodeIds}}
}
function 𝓟1467{restoreEntityReferences} (𝓟1468{nodesMap}: [OOV]𝓟[ty]1381{NodeSnapshotMap},𝓟1469{cacheContext}: 𝓟[ty]406{CacheContext}): (𝓟1470: [miss]𝓛[ty]10033{Void})
{
const 𝓟1471{entityTransformer}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1469{cacheContext}.entityTransformer;
const 𝓟1472{entityIdForValue}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1469{cacheContext}.entityIdForValue;
{
const 𝓟1473{nodeId}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1468{nodesMap});
while (𝓛8744{Boolean})
{
const 𝓟1474{data}: [OOV]𝓟[ty]513{NestedValue} = 𝓟1468{nodesMap}.access(𝓟1473{nodeId}).data;
const 𝓟1475{outbound}: [miss]𝓛[ty]8670{Array} = 𝓟1468{nodesMap}.access(𝓟1473{nodeId}).outbound;
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓟1471{entityTransformer},𝓟235{isObject}(𝓟1474{data})),𝓟1472{entityIdForValue}(𝓟1474{data})))
{
𝓟1471{entityTransformer}(𝓟1474{data})
}
if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟1475{outbound}),𝓛12559{EqualsEqualsEqualsToken}(𝓟1474{data},𝓛12643{undefined})))
{
}
{
const 𝓟1476{referenceId}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟1475{outbound}).id;
const 𝓟1477{path}: [miss]𝓛[ty]8670{Array} = 𝓛12589{$ArrayAccess}(𝓟1475{outbound}).path;
while (𝓛8744{Boolean})
{
const 𝓟1478{referenceNode}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟1468{nodesMap}.access(𝓟1476{referenceId});
if (𝓛12592{AmpersandAmpersandToken}(𝓛1{<UNKNOWN>}(𝓟1478{referenceNode},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟1474{data},𝓛12643{undefined})))
{
𝓟1468{nodesMap}.access(𝓟1473{nodeId}).data ⟵ 𝓟1478{referenceNode}.data;
}
else
{
if (𝓛1{<UNKNOWN>}(𝓟1478{referenceNode},𝓛12643{undefined}))
{
const 𝓟1479{indexToArrayIndex} = 𝓟1532{lodashFindIndex}(𝓟1477{path},𝓟244{isNumber});
if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟1479{indexToArrayIndex},𝓛12616{MinusToken}(𝓛8745{Number})))
{
𝓟1480{tryRestoreSparseArray}(𝓟1474{data},𝓟1477{path},𝓛8745{Number})
}
}
else
{
if (𝓛12546{BarBarToken}(𝓛8757{Array}.isArray(𝓟1474{data}),𝓟235{isObject}(𝓟1474{data})))
{
𝓟1531{lodashSet}(𝓟1474{data},𝓟1477{path},𝓟1478{referenceNode}.data)
}
}
}
}
}
}
}
}
function 𝓟1480{tryRestoreSparseArray} (𝓟1481{data}: [OOV]𝓟[ty]513{NestedValue},𝓟1482{possibleSparseArrayPaths}: 𝓛[ty]8670{Array},𝓟1483{idx}: 𝓛[ty]8655{Number}): (𝓟1484: [miss]𝓛[ty]10033{Void})
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1481{data},𝓛12643{undefined}))
{
𝓛8749{Error}.CONSTRUCTOR(𝓛12607{$Template}(𝓟1482{possibleSparseArrayPaths},𝓟1483{idx}))
}
if (𝓛12546{BarBarToken}(𝓛12546{BarBarToken}(𝓛12596{GreaterThanEqualsToken}(𝓟1483{idx},𝓟1482{possibleSparseArrayPaths}.length),𝓛12559{EqualsEqualsEqualsToken}(𝓟1481{data},𝓛12643{undefined})),𝓟232{isScalar}(𝓟1481{data})))
{
}
const 𝓟1485{prop} = 𝓟1482{possibleSparseArrayPaths}.access(𝓟1483{idx});
if (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛8757{Array}.isArray(𝓟1481{data}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1485{prop}),𝓛8743{String})),𝓛12559{EqualsEqualsEqualsToken}(𝓟1481{data}.access(𝓟1485{prop}),𝓛12643{undefined})))
{
𝓛12622{$Delete}(𝓟1481{data}.access(𝓟1485{prop}))
}
𝓟1480{tryRestoreSparseArray}(𝓟1481{data}.access(𝓟1485{prop}),𝓟1482{possibleSparseArrayPaths},𝓛12641{PlusToken}(𝓟1483{idx},𝓛8745{Number}))
}
Module: src/operations/index
Module: src/operations/write
function 𝓟1503{write} (𝓟1504{context}: 𝓟[ty]406{CacheContext},𝓟1505{snapshot}: 𝓟[ty]1387{GraphSnapshot},𝓟1506{raw}: [OOV]𝓟[ty]787{RawOperation},𝓟1507{payload}: [OOV]𝓟[ty]506{NestedObject}): (𝓟1508: [OOV]𝓟[ty]514{EditedSnapshot})
{
let 𝓟1509{tracerContext};
if (𝓟1504{context}.tracer.writeStart)
{
𝓟1509{tracerContext} ⟵ 𝓟1504{context}.tracer.writeStart(𝓟1506{raw},𝓟1507{payload});
}
const 𝓟1510{editor}: [miss]𝓟[ty]523{SnapshotEditor} = 𝓟517{CONSTRUCTOR}(𝓟1504{context},𝓟1505{snapshot});
const 𝓟1511{warnings}: [miss]𝓛[ty]8670{Array} = 𝓟1510{editor}.mergePayload(𝓟1506{raw},𝓟1507{payload}).warnings;
const 𝓟1512{newSnapshot}: [OOV]𝓟[ty]514{EditedSnapshot} = 𝓟1510{editor}.commit();
if (𝓟1504{context}.tracer.writeEnd)
{
𝓟1504{context}.tracer.writeEnd(𝓟1504{context}.parseOperation(𝓟1506{raw}),{payload: 𝓟1507{payload},newSnapshot: 𝓟1512{newSnapshot},warnings: 𝓟1511{warnings}},𝓟1509{tracerContext})
}
return 𝓟1508 = 𝓟1512{newSnapshot}
}