117 lines
15 KiB
JavaScript
117 lines
15 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.optionalCmp = exports.numberCmp = exports.stringCmp = exports.ref = exports.isEntityCollection = exports.calculatedIndex = exports.fieldIndex = exports.entityCollection = void 0;
|
|
const sorted_map_1 = require("./sorted-map");
|
|
function entityCollection() {
|
|
const entities = new Map();
|
|
const _indexes = {};
|
|
function add(x) {
|
|
entities.set(x.$id, x);
|
|
for (const index of Object.values(_indexes)) {
|
|
// FIXME: why can't we type this?
|
|
index.add(x);
|
|
}
|
|
}
|
|
return {
|
|
type: 'entities',
|
|
entities,
|
|
indexes: _indexes,
|
|
add,
|
|
dehydrate: () => ({
|
|
type: 'entities',
|
|
entities: Array.from(validatePlainObjects(entities).values()),
|
|
}),
|
|
hydrateFrom: (x) => {
|
|
entities.clear();
|
|
for (const e of Object.values(x.entities)) {
|
|
add(e);
|
|
}
|
|
},
|
|
index(indexes) {
|
|
// This limitation exists purely because I couldn't type it otherwise.
|
|
// Declaring a return type of `EntityCollection<A, I | II>` would make a lot
|
|
// of our other type inspection code stop working (the union is hard to pick
|
|
// apart). Since adding indexes in multiple goes is not really a use case,
|
|
// the simpler solution is just to type it as if we replaced all indexes
|
|
// and add a runtime check to make sure the types aren't lying.
|
|
if (Object.keys(_indexes).length > 0) {
|
|
throw new Error('You may only call .index() once on a new collection');
|
|
}
|
|
Object.assign(_indexes, indexes);
|
|
return this;
|
|
},
|
|
};
|
|
}
|
|
exports.entityCollection = entityCollection;
|
|
/**
|
|
* An index that uses the value of an entity's field
|
|
*/
|
|
function fieldIndex(propName, comparator) {
|
|
return calculatedIndex((x) => x[propName], comparator);
|
|
}
|
|
exports.fieldIndex = fieldIndex;
|
|
/**
|
|
* An index that is calculated based on a function applied to an entity
|
|
*/
|
|
function calculatedIndex(fn, comparator) {
|
|
const index = [];
|
|
return {
|
|
add: (x) => sorted_map_1.sortedMap.add(index, comparator, fn(x), x.$id),
|
|
lookups: {
|
|
equals: (value) => sorted_map_1.sortedMap.findAll(index, comparator, value),
|
|
},
|
|
index,
|
|
};
|
|
}
|
|
exports.calculatedIndex = calculatedIndex;
|
|
function isEntityCollection(x) {
|
|
return typeof x === 'object' && !!x && x.type === 'entities';
|
|
}
|
|
exports.isEntityCollection = isEntityCollection;
|
|
function validatePlainObjects(xs) {
|
|
for (const x of xs.values()) {
|
|
if (x.constructor !== Object) {
|
|
throw new Error(`Entities should be plain-text objects, got instance of ${x.constructor}`);
|
|
}
|
|
}
|
|
return xs;
|
|
}
|
|
function ref(x) {
|
|
return typeof x === 'string' ? { $ref: x } : { $ref: x.$id };
|
|
}
|
|
exports.ref = ref;
|
|
/**
|
|
* Determines whether two strings are equivalent in the current or specified locale.
|
|
*/
|
|
function stringCmp(a, b) {
|
|
return a.localeCompare(b);
|
|
}
|
|
exports.stringCmp = stringCmp;
|
|
/**
|
|
* Determines whether two numbers are equivalent.
|
|
*/
|
|
function numberCmp(a, b) {
|
|
return a - b;
|
|
}
|
|
exports.numberCmp = numberCmp;
|
|
/**
|
|
* Creates a comparator to determine equivalent of two values, using a given comparator, but allows values to be optional.
|
|
*
|
|
* @param frontOrder If `true`, returns so that undefined values are ordered at the front. If `false`, undefined values are ordered at the back.
|
|
*/
|
|
function optionalCmp(cmp, frontOrder = true) {
|
|
return (a, b) => {
|
|
if (a == undefined && b != undefined) {
|
|
return frontOrder ? -1 : 1;
|
|
}
|
|
if (a != undefined && b == undefined) {
|
|
return frontOrder ? 1 : -1;
|
|
}
|
|
if (a == undefined && b == undefined) {
|
|
return 0;
|
|
}
|
|
return cmp(a, b);
|
|
};
|
|
}
|
|
exports.optionalCmp = optionalCmp;
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity.js","sourceRoot":"","sources":["../src/entity.ts"],"names":[],"mappings":"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","sourcesContent":["import { sortedMap, SortedMultiMap } from './sorted-map';\n\nexport interface Entity {\n  readonly $id: string;\n}\n\nexport type Plain<E extends Entity> = Omit<E, '$id'>;\n\ntype Indexes<A extends Entity> = { [K in PropertyKey]: EntityIndex<A, any> };\n\nexport interface EntityCollection<A extends Entity, I extends Indexes<Entity> = {}> {\n  readonly type: 'entities';\n  readonly entities: Map<string, A>;\n  readonly indexes: I;\n\n  add(x: A): void;\n  dehydrate(): any;\n  hydrateFrom(x: any): void;\n\n  /**\n   * Add indexes to this collection\n   *\n   * Creating an indexed collection is a two-step operation so that we can specify the\n   * Entity type, but infer the index types (TypeScript does not allow both specifying AND\n   * inferring generic arguments in a single call).\n   */\n  index<II extends Indexes<A>>(indexes: II): EntityCollection<A, II>;\n}\n\n/**\n * Interface for index objects\n */\nexport interface EntityIndex<A extends Entity, IndexType> {\n  /**\n   * The lookups that the indexed field type affords\n   *\n   * For example, 'equals', 'lessThan', 'prefix', etc.\n   */\n  readonly lookups: IndexLookups<IndexType>;\n\n  /**\n   * The index data store\n   */\n  readonly index: SortedMultiMap<IndexType, string>;\n\n  /**\n   * Add an entity to the index\n   */\n  add(x: A): void;\n}\n\n/**\n * Map a type the types of lookups we can do on that type\n */\nexport type IndexLookups<P> = [P] extends [string]\n  ? StringIndexLookups\n  : [P] extends [string | undefined]\n  ? OptionalStringIndexLookups\n  : {};\n\n/**\n * All the lookups on 'string' types\n *\n * We currently only have 'equals' but we could have more :)\n */\nexport interface StringIndexLookups {\n  equals(x: string): string[];\n}\n\n/**\n * All the lookups on 'string | undefined' types\n */\nexport interface OptionalStringIndexLookups {\n  equals(x: string | undefined): string[];\n}\n\nexport function entityCollection<A extends Entity>(): EntityCollection<A, {}> {\n  const entities = new Map<string, A>();\n  const _indexes = {};\n\n  function add(x: A) {\n    entities.set(x.$id, x);\n    for (const index of Object.values(_indexes)) {\n      // FIXME: why can't we type this?\n      (index as any).add(x);\n    }\n  }\n\n  return {\n    type: 'entities',\n    entities,\n    indexes: _indexes as any,\n    add,\n    dehydrate: () => ({\n      type: 'entities',\n      entities: Array.from(validatePlainObjects(entities).values()),\n    }),\n    hydrateFrom: (x) => {\n      entities.clear();\n      for (const e of Object.values(x.entities)) {\n        add(e as any);\n      }\n    },\n    index(indexes) {\n      // This limitation exists purely because I couldn't type it otherwise.\n      // Declaring a return type of `EntityCollection<A, I | II>` would make a lot\n      // of our other type inspection code stop working (the union is hard to pick\n      // apart). Since adding indexes in multiple goes is not really a use case,\n      // the simpler solution is just to type it as if we replaced all indexes\n      // and add a runtime check to make sure the types aren't lying.\n      if (Object.keys(_indexes).length > 0) {\n        throw new Error('You may only call .index() once on a new collection');\n      }\n      Object.assign(_indexes, indexes);\n      return this as any;\n    },\n  };\n}\n\n/**\n * An index that uses the value of an entity's field\n */\nexport function fieldIndex<A extends Entity, P extends keyof A>(\n  propName: P,\n  comparator: sortedMap.Comparator<A[P]>,\n): EntityIndex<A, A[P]> {\n  return calculatedIndex((x) => x[propName], comparator);\n}\n\n/**\n * An index that is calculated based on a function applied to an entity\n */\nexport function calculatedIndex<A extends Entity, B>(fn: (x: A) => B, comparator: sortedMap.Comparator<B>) {\n  const index: SortedMultiMap<B, string> = [];\n  return {\n    add: (x: A) => sortedMap.add(index, comparator, fn(x), x.$id),\n    lookups: {\n      equals: (value: B) => sortedMap.findAll(index, comparator, value),\n    } as any,\n    index,\n  };\n}\n\nexport function isEntityCollection(x: unknown): x is EntityCollection<any> {\n  return typeof x === 'object' && !!x && (x as any).type === 'entities';\n}\n\nfunction validatePlainObjects<A extends object>(xs: Map<string, A>): Map<string, A> {\n  for (const x of xs.values()) {\n    if (x.constructor !== Object) {\n      throw new Error(`Entities should be plain-text objects, got instance of ${x.constructor}`);\n    }\n  }\n  return xs;\n}\n\nexport interface Reference<E extends Entity> {\n  readonly $ref: E['$id'];\n}\n\nexport function ref<E extends Entity>(x: E | string): Reference<E> {\n  return typeof x === 'string' ? { $ref: x } : { $ref: x.$id };\n}\n\n/**\n * Determines whether two strings are equivalent in the current or specified locale.\n */\nexport function stringCmp(a: string, b: string): number {\n  return a.localeCompare(b);\n}\n\n/**\n * Determines whether two numbers are equivalent.\n */\nexport function numberCmp(a: number, b: number): number {\n  return a - b;\n}\n\n/**\n * Creates a comparator to determine equivalent of two values, using a given comparator, but allows values to be optional.\n *\n * @param frontOrder If `true`, returns so that undefined values are ordered at the front. If `false`, undefined values are ordered at the back.\n */\nexport function optionalCmp<A>(cmp: (a: A, b: A) => number, frontOrder = true) {\n  return (a: A | undefined, b: A | undefined) => {\n    if (a == undefined && b != undefined) {\n      return frontOrder ? -1 : 1;\n    }\n    if (a != undefined && b == undefined) {\n      return frontOrder ? 1 : -1;\n    }\n    if (a == undefined && b == undefined) {\n      return 0;\n    }\n\n    return cmp(a!, b!);\n  };\n}\n"]}
|