@routier/core 0.0.1-alpha.1 → 0.0.1-alpha.2

package/dist/codegen/handlers/merge/MergeDefaultValueHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class MergeDefaultValueHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/merge/MergeFunctionHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class MergeFunctionHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/merge/MergePrimitiveHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class MergePrimitiveHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/prepare/PrepareComputedValueHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class PrepareComputedValueHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/prepare/PrepareFunctionHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class PrepareFunctionHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/prepare/PrepareIdentityHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class PrepareIdentityHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/prepare/PrepareKeyHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class PrepareKeyHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/prepare/PrepareObjectHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class PrepareObjectHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/prepare/PrepareValueHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class PrepareValueHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/serialize/SerializeDateHandler.d.ts

@@ -0,0 +1,9 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+/**
+ * Handles converting a Date value from JavaScript to a string value
+ */
+export declare class SerializeDateHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/serialize/SerializeObjectHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class SerializeObjectHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/serialize/SerializeValueHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class SerializeValueHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/strip/StripIdentityHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class StripIdentityHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/strip/StripKeyHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class StripKeyHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/strip/StripObjectHandler.d.ts

@@ -0,0 +1,6 @@
+import { CodeBuilder } from '../../blocks';
+import { PropertyInfoHandler } from "../types";
+import { PropertyInfo } from "../../../schema";
+export declare class StripObjectHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/strip/StripValueHandler.d.ts

@@ -0,0 +1,6 @@
+import { PropertyInfo } from "../../../schema";
+import { PropertyInfoHandler } from "../types";
+import { CodeBuilder } from '../../blocks';
+export declare class StripValueHandler extends PropertyInfoHandler {
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}

package/dist/codegen/handlers/types.d.ts

@@ -0,0 +1,18 @@
+import { CodeBuilder, ContainerBlock } from '..';
+import { PropertyInfo } from '../../schema/PropertyInfo';
+import { SlotPath } from '../SlotPath';
+export interface IHandler {
+    setNext(handler: IHandler): IHandler;
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+}
+export declare abstract class PropertyInfoHandler implements IHandler {
+    private _next;
+    setNext(handler: IHandler): IHandler;
+    handle(property: PropertyInfo<any>, builder: CodeBuilder): CodeBuilder | null;
+    protected buildSlotPath(property: PropertyInfo<any>, path: SlotPath): SlotPath;
+    protected setEnrichedProperty(property: PropertyInfo<any>, root: CodeBuilder): void;
+    protected toNamedFunction(stringifiedFunction: string, parent: ContainerBlock): {
+        builder: import("..").FunctionBuilder;
+        parameters: string[];
+    };
+}

package/{src/codegen/index.ts → dist/codegen/index.d.ts}

@@ -1,2 +1,2 @@
 export * from './blocks';
-export * from './types';
+export * from './types';

package/dist/codegen/types.d.ts

@@ -0,0 +1,9 @@
+export type Insert = {
+    index: number;
+    type: "before" | "after";
+    unshift: boolean;
+};
+export type CreateBlockOptions = {
+    name?: string;
+    unshift?: boolean;
+};

package/dist/codegen/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Counts non-overlapping occurrences of a term in text.
+ *
+ * Behavior:
+ * - Case-sensitive matching
+ * - If the search term is composed entirely of word characters (A–Z, a–z, 0–9, _),
+ *   enforce whole-word boundaries so "red" does not match inside "redder".
+ * - If the search term contains any non-word character (e.g. "=>", "()", "::"),
+ *   match anywhere without boundary checks (useful for symbols).
+ * - Non-overlapping matches (after a hit, advances by term length)
+ * - Optimized single-character fast path; otherwise uses indexOf loop
+ *
+ * Examples:
+ * - countWordOccurance("red redder red", "red") => 2
+ * - countWordOccurance("()=>{}", "=>") => 1
+ * - countWordOccurance("aaaa", "aa") => 2 (non-overlapping)
+ *
+ * @param text The source text to scan
+ * @param word The term to match (must be non-empty)
+ * @returns The number of occurrences found
+ */
+export declare const countWordOccurance: (text: string, word: string) => number;

package/dist/collections/Changes.d.ts

@@ -0,0 +1,51 @@
+import { EntityUpdateInfo } from "../plugins/types";
+import { InferCreateType, InferType, SchemaId } from "../schema";
+import { TagCollection } from "./TagCollection";
+export declare class BulkPersistResult extends Map<SchemaId, SchemaPersistResult> {
+    resolve(schemaId: SchemaId): SchemaPersistResult;
+    get<T extends {} = Record<string, unknown>>(schemaId: SchemaId): SchemaPersistResult<T>;
+    get aggregate(): {
+        size: number;
+        adds: number;
+        updates: number;
+        removes: number;
+    };
+    private get aggregateSize();
+    private get aggregateAddsSize();
+    private get aggregateUpdatesSize();
+    private get aggregateRemovesSize();
+}
+export declare class BulkPersistChanges extends Map<SchemaId, SchemaPersistChanges> {
+    resolve(schemaId: SchemaId): SchemaPersistChanges;
+    get<T extends {} = Record<string, unknown>>(schemaId: SchemaId): SchemaPersistChanges<T>;
+    get aggregate(): {
+        size: number;
+        adds: number;
+        updates: number;
+        removes: number;
+    };
+    private get aggregateSize();
+    private get aggregateAddsSize();
+    private get aggregateUpdatesSize();
+    private get aggregateRemovesSize();
+    /**
+     * Ensures the result has the same result sets as the change sets
+     * @returns
+     */
+    toResult(): BulkPersistResult;
+}
+export declare class SchemaPersistChanges<T extends {} = Record<string, unknown>> {
+    adds: InferCreateType<T>[];
+    updates: EntityUpdateInfo<T>[];
+    removes: InferType<T>[];
+    tags: TagCollection;
+    get hasItems(): boolean;
+    get total(): number;
+}
+export declare class SchemaPersistResult<T extends {} = Record<string, unknown>> {
+    adds: InferType<T>[];
+    updates: InferType<T>[];
+    removes: InferType<T>[];
+    get hasItems(): boolean;
+    get total(): number;
+}

package/dist/collections/Changes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/collections/IdSet.d.ts

@@ -0,0 +1,7 @@
+import { IdType } from "../schema";
+export declare class IdSet {
+    readonly ids: readonly IdType[];
+    constructor(...ids: IdType[]);
+    equals(other: IdSet): boolean;
+    toString(): string;
+}

package/dist/collections/MemoryDataCollection.d.ts

@@ -0,0 +1,22 @@
+import { CompiledSchema, PropertyInfo } from "../schema";
+import { CallbackResult } from "../results";
+export declare class MemoryDataCollection {
+    protected readonly nextNumericalIds: Map<string, number>;
+    protected readonly data: Map<string, Record<string, unknown>>;
+    protected readonly schema: CompiledSchema<any>;
+    protected readonly idProperties: PropertyInfo<any>[];
+    get size(): number;
+    get records(): Record<string, unknown>[];
+    constructor(schema: CompiledSchema<any>);
+    private _getNextId;
+    private getAndSetId;
+    seed(items: Record<string, unknown>[]): void;
+    private resolveCurrentIdSet;
+    private resolveIdSet;
+    add(item: Record<string, unknown>): void;
+    remove(item: Record<string, unknown>): void;
+    update(item: Record<string, unknown>): void;
+    destroy(done: CallbackResult<never>): void;
+    load(done: CallbackResult<never>): void;
+    save(done: CallbackResult<never>): void;
+}

package/dist/collections/MemoryDataCollection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/collections/SchemaCollection.d.ts

@@ -0,0 +1,8 @@
+import { CompiledSchema, SchemaId } from "../schema";
+/**
+ * Collection of schemas with generic typing for type-safe schema retrieval
+ */
+export declare class SchemaCollection extends Map<SchemaId, CompiledSchema<Record<string, unknown>>> {
+    get<T>(schemaId: SchemaId): CompiledSchema<T>;
+    getByName<T>(collectionName: string): CompiledSchema<T> | undefined;
+}

package/dist/collections/TagCollection.d.ts

@@ -0,0 +1,15 @@
+export declare class TagCollection implements Disposable {
+    private data;
+    private _size;
+    get size(): number;
+    get(key: Object): unknown;
+    has(key: Object): boolean;
+    set(key: Object, tag: unknown): Map<Object, unknown>;
+    delete(key: Object): boolean;
+    setMany(keys: Object[], tag: unknown): void;
+    combine(tags: TagCollection): void;
+    values(): MapIterator<unknown>;
+    keys(): MapIterator<Object>;
+    [Symbol.dispose](): void;
+    [Symbol.iterator](): MapIterator<[Object, unknown]>;
+}

package/dist/collections/TagCollection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/{src/collections/index.ts → dist/collections/index.d.ts}

@@ -2,4 +2,4 @@ export * from './Changes';
 export * from './TagCollection';
 export * from './IdSet';
 export * from './MemoryDataCollection';
-export * from './SchemaCollection';
+export * from './SchemaCollection';