@routier/core 0.2.1 → 0.4.0

package/dist/collections/index.cjs

@@ -0,0 +1,702 @@
+(() => {
+"use strict";
+var __webpack_modules__ = ({
+533(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  $E: () => (SchemaPersistChanges),
+  R7: () => (SchemaPersistResult),
+  om: () => (BulkPersistResult),
+  qk: () => (BulkPersistChanges)
+});
+/* import */ var _TagCollection__rspack_import_0 = __webpack_require__(356);
+
+class BulkPersistResult extends Map {
+    resolve(schemaId) {
+        if (this.has(schemaId)) {
+            return this.get(schemaId);
+        }
+        this.set(schemaId, new SchemaPersistResult());
+        return this.get(schemaId);
+    }
+    get(schemaId) {
+        return super.get(schemaId);
+    }
+    get aggregate() {
+        return {
+            size: this.aggregateSize,
+            adds: this.aggregateAddsSize,
+            updates: this.aggregateUpdatesSize,
+            removes: this.aggregateRemovesSize
+        };
+    }
+    get aggregateSize() {
+        let count = 0;
+        for (const [, result] of this){
+            count += result.total;
+        }
+        return count;
+    }
+    get aggregateAddsSize() {
+        let count = 0;
+        for (const [, result] of this){
+            count += result.adds.length;
+        }
+        return count;
+    }
+    get aggregateUpdatesSize() {
+        let count = 0;
+        for (const [, result] of this){
+            count += result.updates.length;
+        }
+        return count;
+    }
+    get aggregateRemovesSize() {
+        let count = 0;
+        for (const [, result] of this){
+            count += result.removes.length;
+        }
+        return count;
+    }
+}
+class BulkPersistChanges extends Map {
+    resolve(schemaId) {
+        if (this.has(schemaId)) {
+            return this.get(schemaId);
+        }
+        this.set(schemaId, new SchemaPersistChanges());
+        return this.get(schemaId);
+    }
+    get(schemaId) {
+        return super.get(schemaId);
+    }
+    get aggregate() {
+        return {
+            size: this.aggregateSize,
+            adds: this.aggregateAddsSize,
+            updates: this.aggregateUpdatesSize,
+            removes: this.aggregateRemovesSize
+        };
+    }
+    get aggregateSize() {
+        let count = 0;
+        for (const [, result] of this){
+            count += result.total;
+        }
+        return count;
+    }
+    get aggregateAddsSize() {
+        let count = 0;
+        for (const [, result] of this){
+            count += result.adds.length;
+        }
+        return count;
+    }
+    get aggregateUpdatesSize() {
+        let count = 0;
+        for (const [, result] of this){
+            count += result.updates.length;
+        }
+        return count;
+    }
+    get aggregateRemovesSize() {
+        let count = 0;
+        for (const [, result] of this){
+            count += result.removes.length;
+        }
+        return count;
+    }
+    /**
+     * Ensures the result has the same result sets as the change sets
+     * @returns 
+     */ toResult() {
+        const result = new BulkPersistResult();
+        for (const [schemaId] of this){
+            result.set(schemaId, new SchemaPersistResult());
+        }
+        return result;
+    }
+}
+class SchemaPersistChanges {
+    adds = [];
+    updates = [];
+    removes = [];
+    tags = new _TagCollection__rspack_import_0/* .TagCollection */.r();
+    get hasItems() {
+        return this.total > 0;
+    }
+    get total() {
+        return this.adds.length + this.updates.length + this.removes.length;
+    }
+}
+class SchemaPersistResult {
+    adds = [];
+    updates = [];
+    removes = [];
+    get hasItems() {
+        return this.total > 0;
+    }
+    get total() {
+        return this.adds.length + this.updates.length + this.removes.length;
+    }
+}
+
+
+},
+995(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  g: () => (ReadonlySchemaCollection)
+});
+/**
+ * Collection of schemas with generic typing for type-safe schema retrieval
+ */ class ReadonlySchemaCollection {
+    data;
+    constructor(data){
+        this.data = new Map(data);
+    }
+    get(schemaId) {
+        return this.data.get(schemaId);
+    }
+    has(schemaId) {
+        return this.data.has(schemaId);
+    }
+    get size() {
+        return this.data.size;
+    }
+    keys() {
+        return this.data.keys();
+    }
+    values() {
+        return this.data.values();
+    }
+    entries() {
+        return this.data.entries();
+    }
+    forEach(callbackfn, thisArg) {
+        this.data.forEach(callbackfn, thisArg);
+    }
+    [Symbol.iterator]() {
+        return this.data[Symbol.iterator]();
+    }
+    getByName(collectionName) {
+        const found = [
+            ...this.data
+        ].find((x)=>x[1].collectionName === collectionName);
+        if (found != null) {
+            return found[1];
+        }
+        return undefined;
+    }
+}
+
+
+},
+393(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  w: () => (SchemaCollection)
+});
+/* import */ var _ReadonlySchemaCollection__rspack_import_0 = __webpack_require__(995);
+
+/**
+ * Collection of schemas with generic typing for type-safe schema retrieval
+ */ class SchemaCollection extends _ReadonlySchemaCollection__rspack_import_0/* .ReadonlySchemaCollection */.g {
+    set(schemaId, schema) {
+        this.data.set(schemaId, schema);
+        return this;
+    }
+    delete(schemaId) {
+        return this.data.delete(schemaId);
+    }
+    clear() {
+        this.data.clear();
+    }
+}
+
+
+},
+356(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  r: () => (TagCollection)
+});
+class TagCollection {
+    data = new Map();
+    // Delegated to the map rather than tracked in a counter field: every mutation path
+    // (set, setMany, combine, delete, dispose) would otherwise have to maintain it, and
+    // a missed path silently reports a size that disagrees with the contents.
+    get size() {
+        return this.data.size;
+    }
+    get(key) {
+        return this.data.get(key);
+    }
+    has(key) {
+        return this.data.has(key);
+    }
+    set(key, tag) {
+        return this.data.set(key, tag);
+    }
+    delete(key) {
+        return this.data.delete(key);
+    }
+    setMany(keys, tag) {
+        for(let i = 0, length = keys.length; i < length; i++){
+            const key = keys[i];
+            this.set(key, tag);
+        }
+    }
+    combine(tags) {
+        for (const [key, value] of tags){
+            this.set(key, value);
+        }
+    }
+    values() {
+        return this.data.values();
+    }
+    keys() {
+        return this.data.keys();
+    }
+    [Symbol.dispose]() {
+        this.data.clear();
+    }
+    [Symbol.iterator]() {
+        return this.data[Symbol.iterator]();
+    }
+}
+
+
+},
+718(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  Q: () => (Result)
+});
+class BaseResult {
+    static ERROR = "error";
+    static SUCCESS = "success";
+    static PARTIAL = "partial";
+    static resolve(result, resolve, reject) {
+        if (result.ok === BaseResult.SUCCESS) {
+            resolve(result.data);
+            return;
+        }
+        if (result.ok === BaseResult.PARTIAL) {
+            reject({
+                partial: result.data,
+                error: result.error
+            });
+            return;
+        }
+        reject(result.error);
+    }
+    static assertSuccess(result) {
+        if (result.ok !== BaseResult.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+class Result extends BaseResult {
+    static success(data) {
+        return {
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(error) {
+        return {
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(data, error) {
+        return {
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+}
+class PluginEventResult extends (/* unused pure expression or super */ null && (BaseResult)) {
+    static success(id, data) {
+        return {
+            id,
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(id, error) {
+        return {
+            id,
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(id, data, error) {
+        return {
+            id,
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+    static assertSuccess(result) {
+        if (result.ok !== Result.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+
+
+},
+537(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  L: () => (SchemaTypes)
+});
+var SchemaTypes = /*#__PURE__*/ function(SchemaTypes) {
+    SchemaTypes["Array"] = "Array";
+    SchemaTypes["Boolean"] = "Boolean";
+    SchemaTypes["Date"] = "Date";
+    SchemaTypes["Number"] = "Number";
+    SchemaTypes["Object"] = "Object";
+    SchemaTypes["String"] = "String";
+    SchemaTypes["Definition"] = "Definition";
+    SchemaTypes["Function"] = "Function";
+    SchemaTypes["Computed"] = "Computed";
+    /**
+     * Content in, reference out. The only type whose write shape differs from its stored
+     * shape, and a leaf on purpose — see `SchemaFile`.
+     */ SchemaTypes["File"] = "File";
+    /**
+     * A fixed-length list of numbers, carrying its dimension count — see `SchemaVector`.
+     *
+     * Value-shaped exactly like `s.array(s.number())`, which is why every array codegen
+     * handler accepts it. It is a distinct type only so a backend can recognise it and store
+     * it natively; nothing else needs to tell the two apart.
+     */ SchemaTypes["Vector"] = "Vector";
+    return SchemaTypes;
+}({});
+var HashType = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(HashType) {
+    HashType["Ids"] = "Ids";
+    HashType["Object"] = "Object";
+    return HashType;
+}({})));
+
+
+},
+618(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  g: () => (uuidv4)
+});
+const uuid = (length = 16)=>{
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charLength = chars.length;
+    let result = '';
+    for(let i = 0; i < length; i++){
+        result += chars[Math.random() * charLength | 0];
+    }
+    return result;
+};
+const HEX_CHARS = '0123456789abcdef';
+const UUID_TEMPLATE = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+const hasCrypto = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function';
+const hasRandomUUID = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function';
+const uuidv4 = ()=>{
+    if (hasRandomUUID) {
+        return crypto.randomUUID();
+    }
+    return uuidv4Fallback();
+};
+const uuidv4Fallback = ()=>{
+    let randomBytes = null;
+    if (hasCrypto) {
+        randomBytes = crypto.getRandomValues(new Uint8Array(16));
+    }
+    let byteIndex = 0;
+    let uuid = '';
+    for(let i = 0; i < UUID_TEMPLATE.length; i++){
+        const c = UUID_TEMPLATE[i];
+        if (c === '-') {
+            uuid += '-';
+            continue;
+        }
+        let r;
+        if (hasCrypto && randomBytes) {
+            // Each byte gives two hex digits (nibbles)
+            r = i % 2 === 0 ? randomBytes[byteIndex] >> 4 : randomBytes[byteIndex++] & 0x0f;
+        } else {
+            r = Math.floor(Math.random() * 16);
+        }
+        if (c === 'x') {
+            uuid += HEX_CHARS[r];
+        } else if (c === 'y') {
+            // Variant bits: 8, 9, A, or B
+            uuid += HEX_CHARS[r & 0x3 | 0x8];
+        } else if (c === '4') {
+            uuid += '4';
+        }
+    }
+    return uuid;
+};
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  SchemaCollection: () => (/* reexport */ SchemaCollection/* .SchemaCollection */.w),
+  IdSet: () => (/* reexport */ IdSet),
+  TagCollection: () => (/* reexport */ TagCollection/* .TagCollection */.r),
+  BulkPersistChanges: () => (/* reexport */ Changes/* .BulkPersistChanges */.qk),
+  BulkPersistResult: () => (/* reexport */ Changes/* .BulkPersistResult */.om),
+  SchemaPersistChanges: () => (/* reexport */ Changes/* .SchemaPersistChanges */.$E),
+  SchemaPersistResult: () => (/* reexport */ Changes/* .SchemaPersistResult */.R7),
+  ReadonlySchemaCollection: () => (/* reexport */ ReadonlySchemaCollection/* .ReadonlySchemaCollection */.g),
+  MemoryDataCollection: () => (/* reexport */ MemoryDataCollection)
+});
+
+// EXTERNAL MODULE: ./src/collections/Changes.ts
+var Changes = __webpack_require__(533);
+// EXTERNAL MODULE: ./src/collections/TagCollection.ts
+var TagCollection = __webpack_require__(356);
+;// CONCATENATED MODULE: ./src/collections/IdSet.ts
+class IdSet {
+    ids;
+    constructor(...ids){
+        this.ids = Object.freeze(ids);
+    }
+    equals(other) {
+        if (this.ids.length === 1) {
+            return this.ids[0] === other.ids[0];
+        }
+        return this.toString() === other.toString();
+    }
+    toString() {
+        if (this.ids.length === 1) {
+            return String(this.ids[0]);
+        }
+        return this.ids.toString();
+    }
+}
+
+// EXTERNAL MODULE: ./src/schema/types.ts
+var types = __webpack_require__(537);
+// EXTERNAL MODULE: ./src/results/Result.ts
+var Result = __webpack_require__(718);
+// EXTERNAL MODULE: ./src/utilities/uuid.ts
+var utilities_uuid = __webpack_require__(618);
+;// CONCATENATED MODULE: ./src/collections/MemoryDataCollection.ts
+
+
+
+
+class MemoryDataCollection {
+    nextNumericalIds;
+    data;
+    schema;
+    idProperties;
+    get size() {
+        return this.data.size;
+    }
+    get records() {
+        return [
+            ...this.data.values()
+        ];
+    }
+    /** Iterates stored records without materializing them into an array. */ values() {
+        return this.data.values();
+    }
+    constructor(schema){
+        this.data = new Map();
+        this.nextNumericalIds = new Map();
+        this.schema = schema;
+        this.idProperties = schema.idProperties;
+    }
+    _getNextId(property) {
+        let nextId = 1;
+        if (this.nextNumericalIds.has(property.id) === true) {
+            nextId = this.nextNumericalIds.get(property.id) + 1;
+        }
+        this.nextNumericalIds.set(property.id, nextId);
+        return nextId;
+    }
+    resolveId(property, value) {
+        if (typeof value !== "number") {
+            return;
+        }
+        const currentIdForProperty = this.nextNumericalIds.get(property.id);
+        if (value <= currentIdForProperty) {
+            return;
+        }
+        this.nextNumericalIds.set(property.id, value);
+    }
+    getAndSetId(item, property) {
+        if (item[property.name] != null) {
+            return item[property.name];
+        }
+        if (property.type === types/* .SchemaTypes.String */.L.String) {
+            const uuid = (0,utilities_uuid/* .uuidv4 */.g)();
+            item[property.name] = uuid;
+            return uuid;
+        }
+        if (property.type === types/* .SchemaTypes.Number */.L.Number) {
+            const id = this._getNextId(property);
+            item[property.name] = id;
+            return id;
+        }
+        throw new Error(`Id Property '${property.name}' must be string or number, found '${property.type}'`);
+    }
+    seed(items) {
+        for(let i = 0, length = items.length; i < length; i++){
+            const id = this.resolveIdSet(items[i]);
+            this.data.set(id.toString(), items[i]);
+        }
+    }
+    resolveCurrentIdSet(item) {
+        const idProperties = this.schema.idProperties;
+        const ids = [];
+        // ensure keys
+        for(let j = 0, l = idProperties.length; j < l; j++){
+            const property = idProperties[j];
+            const value = property.getValue(item);
+            if (value == null) {
+                throw new Error(`Key cannot be null.  Key: ${property.name}`);
+            }
+            ids.push(value);
+        }
+        return new IdSet(...ids);
+    }
+    resolveIdSet(item) {
+        if (this.schema.hasIdentityKeys) {
+            const idProperties = this.schema.idProperties;
+            const ids = Array.from({
+                length: idProperties.length
+            });
+            // Need to make sure we allow for seeding the collection when we call add vs seed
+            // There will be an existing id, but the id type could still be identity
+            if (idProperties.length === 1) {
+                const value = this.getAndSetId(item, idProperties[0]);
+                this.resolveId(idProperties[0], value);
+                ids[0] = value;
+            } else {
+                for(let j = 0, l = idProperties.length; j < l; j++){
+                    const value = this.getAndSetId(item, idProperties[j]);
+                    this.resolveId(idProperties[j], value);
+                    ids[j] = value;
+                }
+            }
+            return new IdSet(...ids);
+        }
+        return this.resolveCurrentIdSet(item);
+    }
+    add(item) {
+        const id = this.resolveIdSet(item);
+        this.data.set(id.toString(), item);
+    }
+    /**
+     * Adds a record only when no record with the same key is present. Durable
+     * collections use this to hydrate stored records around in-memory mutations
+     * without clobbering them.
+     */ addIfAbsent(item) {
+        const id = this.resolveIdSet(item);
+        const key = id.toString();
+        if (this.data.has(key) === false) {
+            this.data.set(key, item);
+        }
+    }
+    /**
+     * Looks up a single record by its key values without scanning the collection.
+     * @param ids Key values in schema id property order
+     * @returns The matching record or undefined when no record has the given key
+     */ getByIds(ids) {
+        return this.data.get(new IdSet(...ids).toString());
+    }
+    remove(item) {
+        const id = this.resolveCurrentIdSet(item);
+        this.data.delete(id.toString());
+    }
+    update(item) {
+        const id = this.resolveCurrentIdSet(item);
+        this.data.set(id.toString(), item);
+    }
+    destroy(done) {
+        this.nextNumericalIds.clear();
+        this.data.clear();
+        done(Result/* .Result.success */.Q.success());
+    }
+    load(done) {
+        done(Result/* .Result.success */.Q.success());
+    }
+    save(done) {
+        done(Result/* .Result.success */.Q.success());
+    }
+}
+
+// EXTERNAL MODULE: ./src/collections/SchemaCollection.ts
+var SchemaCollection = __webpack_require__(393);
+// EXTERNAL MODULE: ./src/collections/ReadonlySchemaCollection.ts
+var ReadonlySchemaCollection = __webpack_require__(995);
+;// CONCATENATED MODULE: ./src/collections/index.ts
+
+
+
+
+
+
+
+})();
+
+module.exports = __webpack_exports__;
+})()
+;
+//# sourceMappingURL=index.cjs.map