@data-client/normalizr
Version:
Normalizes and denormalizes JSON according to schema for Redux and Flux applications
97 lines (93 loc) • 15.9 kB
JavaScript
import { INVALID } from './symbol.js';
import { UNDEF } from './UNDEF.js';
import { isEntity } from '../isEntity.js';
import { denormalize as arrayDenormalize } from '../schemas/Array.js';
import { denormalize as objectDenormalize } from '../schemas/Object.js';
const getUnvisitEntity = (getEntity, cache, args, unvisit) => {
return function unvisitEntity(schema, entityOrId) {
const inputIsId = typeof entityOrId !== 'object';
const entity = inputIsId ? getEntity({
key: schema.key,
pk: entityOrId
}) : entityOrId;
if (typeof entity === 'symbol') {
return schema.denormalize(entity, args, unvisit);
}
if (entity === undefined && inputIsId &&
// entityOrId cannot be undefined literal as this function wouldn't be called in that case
// however the blank strings can still occur
entityOrId !== '' && entityOrId !== 'undefined') {
// we cannot perform WeakMap lookups with `undefined`, so we use a special object to represent undefined
// we're actually using this call to ensure we update the cache if a nested schema changes from `undefined`
// this is because cache.getEntity adds this key,pk as a dependency of anything it is nested under
return cache.getEntity(entityOrId, schema, UNDEF, localCacheKey => {
localCacheKey.set(entityOrId, undefined);
});
}
if (typeof entity !== 'object' || entity === null) {
return entity;
}
let pk = inputIsId ? entityOrId : schema.pk(entity, undefined, undefined, args);
// if we can't generate a working pk we cannot do cache lookups properly,
// so simply denormalize without caching
if (pk === undefined || pk === '' || pk === 'undefined') {
return noCacheGetEntity(localCacheKey => unvisitEntityObject(schema, entity, '', localCacheKey, args, unvisit));
}
// just an optimization to make all cache usages of pk monomorphic
if (typeof pk !== 'string') pk = `${pk}`;
// last function computes if it is not in any caches
return cache.getEntity(pk, schema, entity, localCacheKey => unvisitEntityObject(schema, entity, pk, localCacheKey, args, unvisit));
};
};
function unvisitEntityObject(schema, entity, pk, localCacheKey, args, unvisit) {
const entityCopy = schema.createIfValid(entity);
if (entityCopy === undefined) {
// undefined indicates we should suspense (perhaps failed validation)
localCacheKey.set(pk, INVALID);
} else {
// set before we recurse to prevent cycles causing infinite loops
localCacheKey.set(pk, entityCopy);
// we still need to set in case denormalize recursively finds INVALID
localCacheKey.set(pk, schema.denormalize(entityCopy, args, unvisit));
}
}
function noCacheGetEntity(computeValue) {
const localCacheKey = new Map();
computeValue(localCacheKey);
return localCacheKey.get('');
}
const getUnvisit = (getEntity, cache, args) => {
// we don't inline this as making this function too big inhibits v8's JIT
const unvisitEntity = getUnvisitEntity(getEntity, cache, args, unvisit);
function unvisit(schema, input) {
if (!schema) return input;
if (input === null || input === undefined) {
return input;
}
if (typeof schema.denormalize !== 'function') {
// deserialize fields (like Temporal.Instant)
if (typeof schema === 'function') {
return schema(input);
}
// shorthand for object, array
if (typeof schema === 'object') {
const method = Array.isArray(schema) ? arrayDenormalize : objectDenormalize;
return method(schema, input, args, unvisit);
}
} else {
if (isEntity(schema)) {
return unvisitEntity(schema, input);
}
return schema.denormalize(input, args, unvisit);
}
return input;
}
return (schema, input) => {
// in the case where WeakMap cannot be used
// this test ensures null is properly excluded from WeakMap
const cachable = Object(input) === input && Object(schema) === schema;
return cache.getResults(input, cachable, () => unvisit(schema, input));
};
};
export default getUnvisit;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["INVALID","UNDEF","isEntity","denormalize","arrayDenormalize","objectDenormalize","getUnvisitEntity","getEntity","cache","args","unvisit","unvisitEntity","schema","entityOrId","inputIsId","entity","key","pk","undefined","localCacheKey","set","noCacheGetEntity","unvisitEntityObject","entityCopy","createIfValid","computeValue","Map","get","getUnvisit","input","method","Array","isArray","cachable","Object","getResults"],"sources":["../../src/denormalize/unvisit.ts"],"sourcesContent":["import type Cache from './cache.js';\nimport { INVALID } from './symbol.js';\nimport { UNDEF } from './UNDEF.js';\nimport type { EntityInterface, EntityPath } from '../interface.js';\nimport { isEntity } from '../isEntity.js';\nimport type { DenormGetEntity } from '../memo/types.js';\nimport { denormalize as arrayDenormalize } from '../schemas/Array.js';\nimport { denormalize as objectDenormalize } from '../schemas/Object.js';\n\nconst getUnvisitEntity = (\n  getEntity: DenormGetEntity,\n  cache: Cache,\n  args: readonly any[],\n  unvisit: (schema: any, input: any) => any,\n) => {\n  return function unvisitEntity(\n    schema: EntityInterface,\n    entityOrId: Record<string, any> | string,\n  ): object | undefined | typeof INVALID {\n    const inputIsId = typeof entityOrId !== 'object';\n    const entity =\n      inputIsId ? getEntity({ key: schema.key, pk: entityOrId }) : entityOrId;\n    if (typeof entity === 'symbol') {\n      return schema.denormalize(entity, args, unvisit);\n    }\n\n    if (\n      entity === undefined &&\n      inputIsId &&\n      // entityOrId cannot be undefined literal as this function wouldn't be called in that case\n      // however the blank strings can still occur\n      entityOrId !== '' &&\n      entityOrId !== 'undefined'\n    ) {\n      // we cannot perform WeakMap lookups with `undefined`, so we use a special object to represent undefined\n      // we're actually using this call to ensure we update the cache if a nested schema changes from `undefined`\n      // this is because cache.getEntity adds this key,pk as a dependency of anything it is nested under\n      return cache.getEntity(entityOrId, schema, UNDEF, localCacheKey => {\n        localCacheKey.set(entityOrId, undefined);\n      });\n    }\n\n    if (typeof entity !== 'object' || entity === null) {\n      return entity as any;\n    }\n\n    let pk: string | number | undefined =\n      inputIsId ? entityOrId : (\n        (schema.pk(entity, undefined, undefined, args) as any)\n      );\n\n    // if we can't generate a working pk we cannot do cache lookups properly,\n    // so simply denormalize without caching\n    if (pk === undefined || pk === '' || pk === 'undefined') {\n      return noCacheGetEntity(localCacheKey =>\n        unvisitEntityObject(schema, entity, '', localCacheKey, args, unvisit),\n      );\n    }\n\n    // just an optimization to make all cache usages of pk monomorphic\n    if (typeof pk !== 'string') pk = `${pk}`;\n\n    // last function computes if it is not in any caches\n    return cache.getEntity(pk, schema, entity, localCacheKey =>\n      unvisitEntityObject(schema, entity, pk, localCacheKey, args, unvisit),\n    );\n  };\n};\n\nfunction unvisitEntityObject(\n  schema: EntityInterface<any>,\n  entity: object,\n  pk: string,\n  localCacheKey: Map<string, any>,\n  args: readonly any[],\n  unvisit: (schema: any, input: any) => any,\n): void {\n  const entityCopy = schema.createIfValid(entity);\n\n  if (entityCopy === undefined) {\n    // undefined indicates we should suspense (perhaps failed validation)\n    localCacheKey.set(pk, INVALID);\n  } else {\n    // set before we recurse to prevent cycles causing infinite loops\n    localCacheKey.set(pk, entityCopy);\n    // we still need to set in case denormalize recursively finds INVALID\n    localCacheKey.set(pk, schema.denormalize(entityCopy, args, unvisit));\n  }\n}\n\nfunction noCacheGetEntity(\n  computeValue: (localCacheKey: Map<string, any>) => void,\n): object | undefined | typeof INVALID {\n  const localCacheKey = new Map<string, any>();\n  computeValue(localCacheKey);\n\n  return localCacheKey.get('');\n}\n\nconst getUnvisit = (\n  getEntity: DenormGetEntity,\n  cache: Cache,\n  args: readonly any[],\n) => {\n  // we don't inline this as making this function too big inhibits v8's JIT\n  const unvisitEntity = getUnvisitEntity(getEntity, cache, args, unvisit);\n  function unvisit(schema: any, input: any): any {\n    if (!schema) return input;\n\n    if (input === null || input === undefined) {\n      return input;\n    }\n\n    if (typeof schema.denormalize !== 'function') {\n      // deserialize fields (like Temporal.Instant)\n      if (typeof schema === 'function') {\n        return schema(input);\n      }\n\n      // shorthand for object, array\n      if (typeof schema === 'object') {\n        const method =\n          Array.isArray(schema) ? arrayDenormalize : objectDenormalize;\n        return method(schema, input, args, unvisit);\n      }\n    } else {\n      if (isEntity(schema)) {\n        return unvisitEntity(schema, input);\n      }\n\n      return schema.denormalize(input, args, unvisit);\n    }\n\n    return input;\n  }\n\n  return (schema: any, input: any): { data: any; paths: EntityPath[] } => {\n    // in the case where WeakMap cannot be used\n    // this test ensures null is properly excluded from WeakMap\n    const cachable = Object(input) === input && Object(schema) === schema;\n    return cache.getResults(input, cachable, () => unvisit(schema, input));\n  };\n};\nexport default getUnvisit;\n"],"mappings":"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","ignoreList":[]}