@player-ui/partial-match-registry 0.0.1-next.1

package/dist/index.cjs.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var SortedArray = require('sorted-array');
+var dlv = require('dlv');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var SortedArray__default = /*#__PURE__*/_interopDefaultLegacy(SortedArray);
+var dlv__default = /*#__PURE__*/_interopDefaultLegacy(dlv);
+
+function traverseObj(object, path = [], pairs = new Map()) {
+  for (const key of Object.keys(object)) {
+    const val = object[key];
+    const nestedPath = [...path, key];
+    if (typeof val === "object") {
+      traverseObj(val, nestedPath, pairs);
+    } else {
+      pairs.set(nestedPath, val);
+    }
+  }
+  return pairs;
+}
+function createMatcher(partialObj) {
+  const pairs = traverseObj(partialObj);
+  const matchFunction = (searchObj) => {
+    for (const entry of pairs) {
+      const [path, value] = entry;
+      if (dlv__default["default"](searchObj, path) !== value) {
+        return false;
+      }
+    }
+    return true;
+  };
+  matchFunction.count = pairs.size;
+  return matchFunction;
+}
+
+function createBasicMatcher(seed) {
+  const matcher = (match) => seed === match;
+  matcher.count = 1;
+  return matcher;
+}
+const createSortedArray = () => new SortedArray__default["default"]([], (c) => c.matcher.count);
+class Registry {
+  constructor(initialSet) {
+    this.store = createSortedArray();
+    initialSet == null ? void 0 : initialSet.forEach(([match, value]) => {
+      this.set(match, value);
+    });
+  }
+  set(match, value) {
+    const matcher = typeof match === "object" ? createMatcher(match) : createBasicMatcher(match);
+    this.store.insert({
+      key: match,
+      value,
+      matcher
+    });
+  }
+  get(query) {
+    for (const entry of this.store.array) {
+      if (entry.matcher(query)) {
+        return entry.value;
+      }
+    }
+  }
+  forEach(callbackfn) {
+    for (const entry of this.store.array) {
+      callbackfn(entry);
+    }
+  }
+  clear() {
+    this.store = createSortedArray();
+  }
+}
+
+exports.Registry = Registry;
+exports.createObjectMatcher = createMatcher;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+/** A function that checks overlapping properties against a reference value */
+declare type Matcher = ((searchObj: object) => boolean) & {
+    /** The count represents the specificity of this matcher */
+    count: number;
+};
+/** Given an object, create a function that compares any set key/value pairs in the given object against a new value */
+declare function createMatcher(partialObj: object): Matcher;
+
+interface RegistryIndex<V> {
+    /** The original object we wanted to match on  */
+    key: object;
+    /** The value to return */
+    value: V;
+    /** The matcher function for this entry */
+    matcher: Matcher;
+}
+/**
+ * A partial match registry is a map that uses an object to "match" against keys.
+ * More specific matches take precedence over less specific ones.
+ */
+declare class Registry<V> {
+    private store;
+    constructor(initialSet?: Array<[any, V]>);
+    /** Add match -> value mapping to the registry */
+    set(match: any, value: V): void;
+    /** Fetch the best match in the registry */
+    get(query: any): V | undefined;
+    /** Loop over all entries and run callback */
+    forEach(callbackfn: (value: RegistryIndex<V>) => void): void;
+    /** Reset the items in the registry */
+    clear(): void;
+}
+
+export { Registry, createMatcher as createObjectMatcher };

package/dist/index.esm.js

@@ -0,0 +1,70 @@
+import SortedArray from 'sorted-array';
+import dlv from 'dlv';
+
+function traverseObj(object, path = [], pairs = new Map()) {
+  for (const key of Object.keys(object)) {
+    const val = object[key];
+    const nestedPath = [...path, key];
+    if (typeof val === "object") {
+      traverseObj(val, nestedPath, pairs);
+    } else {
+      pairs.set(nestedPath, val);
+    }
+  }
+  return pairs;
+}
+function createMatcher(partialObj) {
+  const pairs = traverseObj(partialObj);
+  const matchFunction = (searchObj) => {
+    for (const entry of pairs) {
+      const [path, value] = entry;
+      if (dlv(searchObj, path) !== value) {
+        return false;
+      }
+    }
+    return true;
+  };
+  matchFunction.count = pairs.size;
+  return matchFunction;
+}
+
+function createBasicMatcher(seed) {
+  const matcher = (match) => seed === match;
+  matcher.count = 1;
+  return matcher;
+}
+const createSortedArray = () => new SortedArray([], (c) => c.matcher.count);
+class Registry {
+  constructor(initialSet) {
+    this.store = createSortedArray();
+    initialSet == null ? void 0 : initialSet.forEach(([match, value]) => {
+      this.set(match, value);
+    });
+  }
+  set(match, value) {
+    const matcher = typeof match === "object" ? createMatcher(match) : createBasicMatcher(match);
+    this.store.insert({
+      key: match,
+      value,
+      matcher
+    });
+  }
+  get(query) {
+    for (const entry of this.store.array) {
+      if (entry.matcher(query)) {
+        return entry.value;
+      }
+    }
+  }
+  forEach(callbackfn) {
+    for (const entry of this.store.array) {
+      callbackfn(entry);
+    }
+  }
+  clear() {
+    this.store = createSortedArray();
+  }
+}
+
+export { Registry, createMatcher as createObjectMatcher };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@player-ui/partial-match-registry",
+  "version": "0.0.1-next.1",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {},
+  "dependencies": {
+    "dlv": "^1.1.3",
+    "@types/dlv": "^1.1.2",
+    "sorted-array": "^2.0.4",
+    "@babel/runtime": "7.15.4"
+  },
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "typings": "dist/index.d.ts"
+}

package/src/deep-partial-matcher.ts

@@ -0,0 +1,52 @@
+import dlv from 'dlv';
+
+/** A function that checks overlapping properties against a reference value */
+export type Matcher = ((searchObj: object) => boolean) & {
+  /** The count represents the specificity of this matcher */
+  count: number;
+};
+
+/** Traverse an object and collect any key/value pairs including nested keys */
+function traverseObj(
+  object: Record<any, any>,
+  path: string[] = [],
+  pairs: Map<string[], any> = new Map()
+): Map<string[], any> {
+  for (const key of Object.keys(object)) {
+    const val: any = object[key];
+    const nestedPath = [...path, key];
+    ('');
+
+    if (typeof val === 'object') {
+      traverseObj(val, nestedPath, pairs);
+    } else {
+      pairs.set(nestedPath, val);
+    }
+  }
+
+  return pairs;
+}
+
+/** Given an object, create a function that compares any set key/value pairs in the given object against a new value */
+export default function createMatcher(partialObj: object): Matcher {
+  // Convert the partial object into a list of [key, value] pairs;
+  const pairs = traverseObj(partialObj);
+
+  /** Generate a function to match against all of the properties we care about */
+  const matchFunction = (searchObj: object) => {
+    for (const entry of pairs) {
+      const [path, value] = entry;
+
+      if (dlv(searchObj, path) !== value) {
+        return false;
+      }
+    }
+
+    return true;
+  };
+
+  // Keep track of the specificity of the comparator
+  matchFunction.count = pairs.size;
+
+  return matchFunction;
+}

package/src/index.ts

@@ -0,0 +1,78 @@
+import SortedArray from 'sorted-array';
+import type { Matcher } from './deep-partial-matcher';
+import createObjectMatcher from './deep-partial-matcher';
+
+export { default as createObjectMatcher } from './deep-partial-matcher';
+
+/** create a matcher function that matches exactly */
+function createBasicMatcher(seed: any): Matcher {
+  /** a simple matcher function that only matches itself */
+  const matcher = (match: any) => seed === match;
+  matcher.count = 1;
+
+  return matcher;
+}
+
+interface RegistryIndex<V> {
+  /** The original object we wanted to match on  */
+  key: object;
+
+  /** The value to return */
+  value: V;
+
+  /** The matcher function for this entry */
+  matcher: Matcher;
+}
+
+/** create an empty sorted array using the matcher count */
+const createSortedArray = <V>() =>
+  new SortedArray<RegistryIndex<V>>([], (c) => c.matcher.count);
+
+/**
+ * A partial match registry is a map that uses an object to "match" against keys.
+ * More specific matches take precedence over less specific ones.
+ */
+export class Registry<V> {
+  private store = createSortedArray<V>();
+
+  constructor(initialSet?: Array<[any, V]>) {
+    initialSet?.forEach(([match, value]) => {
+      this.set(match, value);
+    });
+  }
+
+  /** Add match -> value mapping to the registry */
+  set(match: any, value: V) {
+    const matcher =
+      typeof match === 'object'
+        ? createObjectMatcher(match)
+        : createBasicMatcher(match);
+
+    this.store.insert({
+      key: match,
+      value,
+      matcher,
+    });
+  }
+
+  /** Fetch the best match in the registry */
+  get(query: any): V | undefined {
+    for (const entry of this.store.array) {
+      if (entry.matcher(query)) {
+        return entry.value;
+      }
+    }
+  }
+
+  /** Loop over all entries and run callback */
+  forEach(callbackfn: (value: RegistryIndex<V>) => void): void {
+    for (const entry of this.store.array) {
+      callbackfn(entry);
+    }
+  }
+
+  /** Reset the items in the registry */
+  clear() {
+    this.store = createSortedArray<V>();
+  }
+}