@routier/core 0.2.1 → 0.4.0

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

@@ -1,15 +1,69 @@
-import { CodeBuilder, ContainerBlock } from '..';
+import { CodeBuilder, ContainerBlock, IfBuilder, SlotBlock } 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;
 }
+/**
+ * Terminal link for chains that apply only to a subset of properties (keys,
+ * identities).  Returning the builder marks every other property as
+ * deliberately skipped, so a null return from any chain always means a real
+ * coverage gap.
+ */
+export declare class NotApplicableHandler implements IHandler {
+    setNext(handler: IHandler): IHandler;
+    handle(_: 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;
+    /**
+     * Dotted property path from the root entity (e.g. `nested.inner`), used as the
+     * change-tracking path prefix so nested writes record against the root's
+     * `__tracking__` under their full path.
+     */
+    protected getTrackingPath(property: PropertyInfo<any>): string;
+    /**
+     * Emits `if (<root>.a == null) <root>.a = {};` for every ancestor of a
+     * nested property, so assignments through the target object never throw when a
+     * parent object is absent. The guards run root-down, so grandparents are
+     * materialized before their children.
+     */
+    protected emitDestinationAncestorGuards(property: PropertyInfo<any>, block: IfBuilder, options?: {
+        root?: string;
+        useFromPropertyName?: boolean;
+    }): void;
+    /**
+     * Emits the guarded nested-property assignment shared by the serialize handlers:
+     * reads the parent through an optional-chained selector (the entity may be a
+     * partial — a delta payload or a create payload with absent nested parents),
+     * materializes every `result` ancestor, then assigns `valueExpression` to the
+     * property's storage-side path.
+     */
+    protected emitSerializeNestedAssignment(property: PropertyInfo<any>, slot: SlotBlock, valueExpression: string): void;
+    /**
+     * Emits the source → destination copy for one property in the merge generator,
+     * materializing destination ancestors first.
+     *
+     * With `onlyWhenChanged`, the assignment is skipped when both sides already hold
+     * the same value (compared via `valueOf`, so equal Dates match). This preserves
+     * reference identity on the destination when a merge carries no new information —
+     * callers hold on to entity instances (e.g. a Date returned from add) and must not
+     * see them silently replaced by an equal copy.
+     */
+    protected emitMergeCopy(property: PropertyInfo<any>, builder: CodeBuilder, options?: {
+        onlyWhenChanged?: boolean;
+    }): void;
+    /**
+     * Slot path of the ObjectBuilder that renders `property` inside the enriched
+     * literal. Builders are registered as `[enriched.<path>]` under their parent
+     * builder, so the lookup path must include every ancestor segment — a flat
+     * root-level lookup only works for depth-1 properties.
+     */
+    protected buildEnrichedObjectSlotPath(property: PropertyInfo<any>, base: SlotPath): SlotPath;
     protected setEnrichedProperty(property: PropertyInfo<any>, root: CodeBuilder): void;
     protected toNamedFunction(stringifiedFunction: string, parent: ContainerBlock): {
         builder: import("..").FunctionBuilder;

package/dist/codegen/index.cjs

@@ -0,0 +1,618 @@
+(() => {
+"use strict";
+var __webpack_modules__ = ({
+980(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  $j: () => (ArrayBuilder),
+  E2: () => (SlotBlock),
+  Nl: () => (CodeBuilder),
+  No: () => (AndBuilder),
+  O_: () => (FunctionFactoryBuilder),
+  Tl: () => (ObjectBuilder),
+  Zm: () => (IfBuilder),
+  eB: () => (Block),
+  fe: () => (StringBuilder),
+  hL: () => (AssignmentBuilder),
+  j7: () => (ContainerBlock),
+  kF: () => (FunctionBuilder),
+  ot: () => (VariableBuilder),
+  qY: () => (RawBuilder)
+});
+/* import */ var _utilities__rspack_import_0 = __webpack_require__(618);
+
+class Block {
+    name;
+    _lines = [];
+    _indent = "";
+    _parent;
+    constructor(name, parentIndent = "", parent){
+        this.name = name != null ? name : (0,_utilities__rspack_import_0/* .uuid */.u)();
+        this._indent = parentIndent;
+        this._parent = parent;
+    }
+    indexOf(name) {
+        return this._lines.findIndex((w)=>typeof w !== "string" && w.name === name);
+    }
+    getLines() {
+        return this._lines;
+    }
+    getParent() {
+        return this._parent;
+    }
+    getIndent() {
+        return this._indent;
+    }
+    setLines(lines) {
+        this._lines = lines;
+    }
+    setParent(block) {
+        this._parent = block;
+    }
+    setIndent(indent) {
+        this._indent = indent;
+    }
+    getOrDefault(name) {
+        if (name.includes('.') === false) {
+            return this._lines.find((w)=>typeof w !== "string" && w.name === name);
+        }
+        const split = name.match(/(\[[^\]]+\]|[^.]+)/g);
+        // oxlint-disable-next-line no-this-alias
+        let result = this;
+        for (const item of split){
+            const found = result._lines.find((w)=>typeof w !== "string" && w.name === item);
+            if (found == null) {
+                if ("getValue" in result && result.getValue instanceof Block && result.getValue.name === item) {
+                    result = result.getValue;
+                    continue;
+                }
+                return undefined;
+            }
+            result = found;
+        }
+        return result;
+    }
+    get(name) {
+        const found = this.getOrDefault(name);
+        if (found == null) {
+            throw new Error(`Error finding code block for given path.  Path: ${name}`);
+        }
+        return found;
+    }
+    has(name) {
+        return this._lines.some((w)=>typeof w !== "string" && w.name === name);
+    }
+    remove(name) {
+        this._lines = this._lines.filter((x)=>typeof x === "object" && typeof x.name === "string" && x.name !== name);
+    }
+    replace(name, line) {
+        const foundIndex = this._lines.findIndex((x)=>typeof x !== "string" && x.name === name);
+        if (foundIndex === -1) {
+            throw new Error(`Cannot find line by name.  Name: ${name}`);
+        }
+        const found = this._lines[foundIndex];
+        if (typeof found === "string") {
+            // Replace the line
+            this._lines.splice(foundIndex, 1, line);
+            return;
+        }
+        line.setLines(found.getLines());
+        line.setIndent(found.getIndent());
+        line.setParent(found.getParent());
+        // Replace the line
+        this._lines.splice(foundIndex, 1, line);
+        return;
+    }
+    push(line) {
+        this._lines.push(line);
+    }
+    unshift(line) {
+        this._lines.unshift(line);
+    }
+    indent(text) {
+        return this._indent + text;
+    }
+}
+class ContainerBlock extends Block {
+    if(condition, options) {
+        const builder = new IfBuilder(condition, options?.name, this._indent + "  ", this);
+        if (options?.unshift === true) {
+            this.unshift(builder);
+        } else {
+            this.push(builder);
+        }
+        return builder;
+    }
+    raw(raw, options) {
+        const builder = new RawBuilder(raw, options?.name, this._indent + "  ", this);
+        this.push(builder);
+        return builder;
+    }
+    function(name, options) {
+        const builder = new FunctionBuilder(name, options?.name, this._indent + "  ", this);
+        this.push(builder);
+        return builder;
+    }
+    factory(name, options) {
+        const builder = new FunctionFactoryBuilder(name, options?.name, this._indent + "  ", this);
+        this.push(builder);
+        return builder;
+    }
+    variable(declaration, options) {
+        const builder = new VariableBuilder(declaration, options?.name, this._indent + "  ", this);
+        this.push(builder);
+        return builder;
+    }
+    assign(variableName, options) {
+        const builder = new AssignmentBuilder(variableName, options?.name, this._indent + "  ", this);
+        this.push(builder);
+        return builder;
+    }
+    object(options) {
+        const builder = new ObjectBuilder(options?.name, this._indent + "  ", this);
+        this.push(builder);
+        return builder;
+    }
+    slot(name) {
+        const builder = new SlotBlock(name, this._indent + "  ", this);
+        this.push(builder);
+        return builder;
+    }
+    array(accessor, options) {
+        const builder = new ArrayBuilder(accessor, options?.name, this._indent + "  ", this);
+        this.push(builder);
+        return builder;
+    }
+}
+class StringBuilder extends Block {
+    _type;
+    constructor(type, name, parentIndent = "", parent){
+        super(name, parentIndent, parent);
+        this._type = type;
+    }
+    append(value) {
+        this._lines.push(value);
+        return this;
+    }
+    toString() {
+        if (this._type === "template") {
+            return "`" + this._lines.join("") + "`";
+        }
+        return `"${this._lines.join("")}"`;
+    }
+}
+class SlotBlock extends ContainerBlock {
+    constructor(name, parentIndent = "", parent){
+        super(name, parentIndent, parent);
+    }
+    insert(line) {
+        this.push(line);
+    }
+    toString() {
+        return this._lines.map((line)=>typeof line === 'string' ? this.indent(line) : line.toString()).join('\n\n');
+    }
+}
+class AssignmentBuilder extends ContainerBlock {
+    _variableName;
+    _value;
+    _functionName;
+    get getValue() {
+        return this._value;
+    }
+    constructor(variableName, name, parentIndent = "", parent){
+        super(name, parentIndent, parent);
+        this._variableName = variableName;
+    }
+    value(value) {
+        this._value = value;
+        return this;
+    }
+    and(and, options) {
+        this._value = new AndBuilder(and, options?.name, this._indent, this);
+        return this;
+    }
+    object(options) {
+        const objectBuilder = new ObjectBuilder(options?.name, this._indent, this);
+        this._value = objectBuilder;
+        return objectBuilder;
+    }
+    call(functionName, options) {
+        this._functionName = functionName;
+        const objectBuilder = new ObjectBuilder(options?.name, this._indent, this);
+        this._value = objectBuilder;
+        return objectBuilder;
+    }
+    string(type, options) {
+        const stringBuilder = new StringBuilder(type, options?.name, this._indent, this);
+        this._value = stringBuilder;
+        return stringBuilder;
+    }
+    toString() {
+        if (this._value == null) {
+            throw new Error("Value cannot be null for AssignmentBuilder Builder");
+        }
+        if (this._functionName != null) {
+            return this.indent(`${this._variableName} = ${this._functionName}(${this._value.toString()});`);
+        }
+        return this.indent(`${this._variableName} = ${this._value.toString()};`);
+    }
+}
+class AndBuilder extends ContainerBlock {
+    constructor(and, name, parentIndent = "", parent){
+        super(name, parentIndent, parent);
+        this._lines.push(and);
+    }
+    and(and) {
+        this._lines.push(and);
+    }
+    toString() {
+        return this._lines.join(" && ");
+    }
+}
+class VariableBuilder extends Block {
+    _declaration;
+    _value;
+    get getValue() {
+        return this._value;
+    }
+    constructor(declaration, name, parentIndent = "", parent){
+        super(name, parentIndent, parent);
+        this._declaration = declaration;
+    }
+    value(value) {
+        this._value = value;
+        return this;
+    }
+    object(options) {
+        const objectBuilder = new ObjectBuilder(options?.name, this._indent, this);
+        this._value = objectBuilder;
+        return objectBuilder;
+    }
+    array(accessor, options) {
+        const arrayBuilder = new ArrayBuilder(accessor, options?.name, this._indent, this);
+        this._value = arrayBuilder;
+        return arrayBuilder;
+    }
+    toString() {
+        if (this._value == null) {
+            throw new Error("Value cannot be null for Variable Builder");
+        }
+        return this.indent(`const ${this._declaration} = ${this._value.toString()};`);
+    }
+}
+class RawBuilder extends ContainerBlock {
+    _raw;
+    constructor(raw, name, parentIndent = "", parent){
+        super(name, parentIndent, parent);
+        this._raw = raw;
+    }
+    toString() {
+        return `${this._raw}\n`;
+    }
+}
+class ObjectBuilder extends Block {
+    property(line) {
+        // Add comma to previous line if it exists and isn't a brace
+        if (this._lines.length > 0) {
+            const lastLine = this._lines[this._lines.length - 1];
+            if (typeof lastLine === 'string' && !lastLine.endsWith("{")) {
+                this._lines[this._lines.length - 1] = lastLine + ",";
+            }
+        }
+        this.push(line);
+        return this;
+    }
+    nested(propertyName, name) {
+        const builder = new ObjectBuilder(name, this._indent + "  ", this);
+        // Add comma to previous line if it exists and isn't a brace
+        if (this._lines.length > 0) {
+            const lastLine = this._lines[this._lines.length - 1];
+            if (typeof lastLine === 'string' && !lastLine.endsWith("{")) {
+                this._lines[this._lines.length - 1] = lastLine + ",";
+            }
+        }
+        // Add the property name and opening brace
+        this.push(`${propertyName}: {`);
+        // Add the nested builder
+        this.push(builder);
+        // Add the closing brace
+        this.push("}");
+        return builder;
+    }
+    toString() {
+        // Check if this is a nested object's content
+        const isNestedContent = this._parent instanceof ObjectBuilder;
+        if (isNestedContent) {
+            // For nested object contents, just return the lines
+            return this._lines.map((line)=>typeof line === 'string' ? this.indent("  " + line) : line.toString()).join('\n');
+        }
+        // For root objects, include the braces
+        const lines = [
+            "{",
+            ...this._lines.map((line)=>typeof line === 'string' ? this.indent("  " + line) : line.toString()),
+            this.indent("}")
+        ];
+        return lines.join('\n');
+    }
+}
+class FunctionFactoryBuilder extends ContainerBlock {
+    _functionName;
+    _params = [];
+    _return = false;
+    constructor(functionName, sectionName, parentIndent = "", parent){
+        super(sectionName, parentIndent, parent);
+        this._functionName = functionName;
+    }
+    getParameters() {
+        return [
+            ...this._params
+        ];
+    }
+    createParameter(value) {
+        const name = `injection${this._params.length}`;
+        return {
+            name,
+            value
+        };
+    }
+    parameters(...params) {
+        this._params.push(...params);
+        return this;
+    }
+    return() {
+        this._return = true;
+        return this;
+    }
+    appendBody(line) {
+        this.push(line);
+        return this;
+    }
+    invoke() {
+        const body = this.toString();
+        const parameterNames = this._getParameterNames();
+        const parameterValues = this._getParameterValues();
+        return Function(...parameterNames, body)(...parameterValues);
+    }
+    _getParameterNames() {
+        return this._params.map((w)=>w.name).join(", ");
+    }
+    _getParameterValues() {
+        return this._params.map((w)=>w.value);
+    }
+    toString() {
+        const r = this._return === true ? "return " : "";
+        const signature = this._functionName ? `${r}function ${this._functionName}(${this._getParameterNames()})` : `${r}function(${this._getParameterNames()})`;
+        const lines = [
+            this.indent(signature + " {"),
+            ...this._lines.map((line)=>typeof line === 'string' ? this.indent("  " + line) : line.toString()),
+            this.indent("}")
+        ];
+        return lines.join('\n');
+    }
+}
+class FunctionBuilder extends ContainerBlock {
+    _functionName;
+    _params = [];
+    _return = false;
+    constructor(functionName, sectionName, parentIndent = "", parent){
+        super(sectionName, parentIndent, parent);
+        this._functionName = functionName;
+    }
+    parameters(...params) {
+        this._params.push(...params);
+        return this;
+    }
+    return() {
+        this._return = true;
+        return this;
+    }
+    appendBody(line) {
+        this.push(line);
+        return this;
+    }
+    _getParameterKeys() {
+        return this._params.map((w)=>typeof w === "object" ? w.name : w).join(", ");
+    }
+    toCallable() {
+        return `${this._functionName}(${this._params.map((w)=>typeof w === "object" ? w.callName : w).join(", ")})`;
+    }
+    toString() {
+        const r = this._return === true ? "return " : "";
+        const signature = this._functionName ? `${r}function ${this._functionName}(${this._getParameterKeys()})` : `${r}function(${this._getParameterKeys()})`;
+        const lines = [
+            this.indent(signature + " {"),
+            ...this._lines.map((line)=>typeof line === 'string' ? this.indent("  " + line) : line.toString()),
+            this.indent("}")
+        ];
+        return lines.join('\n');
+    }
+}
+class ArrayBuilder extends Block {
+    constructor(accessor, name, parentIndent = "", parent){
+        super(name, parentIndent, parent);
+        this._lines.push(accessor);
+    }
+    append(accessor) {
+        this._lines.push(accessor);
+        return this;
+    }
+    toString() {
+        return `[${this._lines.join(",")}]`;
+    }
+}
+class IfBuilder extends ContainerBlock {
+    _condition;
+    constructor(condition, name, parentIndent = "", parent){
+        super(name, parentIndent, parent);
+        this._condition = condition;
+    }
+    appendBody(line) {
+        this.push(line);
+        return this;
+    }
+    unshiftBody(line) {
+        this.unshift(line);
+        return this;
+    }
+    stringifyLine(line) {
+        if (typeof line === 'string') {
+            return this.indent("  " + line);
+        }
+        if (Array.isArray(line)) {
+            return line.join("\r\n");
+        }
+        return line.toString();
+    }
+    toString() {
+        // need to join with \r\n because we are not an object
+        const lines = [
+            this.indent(`if (${this._condition}) {`),
+            this._lines.map((x)=>this.stringifyLine(x)).join("\r\n"),
+            this.indent("}")
+        ];
+        return lines.join("\n\n");
+    }
+}
+class CodeBuilder extends ContainerBlock {
+    toString() {
+        return this._lines.map((line)=>typeof line === 'string' ? this.indent(line) : line.toString()).join('\n\n');
+    }
+}
+
+
+},
+618(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  u: () => (uuid)
+});
+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.
+(() => {
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  AndBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.No),
+  ArrayBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.$j),
+  AssignmentBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.hL),
+  Block: () => (/* reexport safe */ _blocks__rspack_import_0.eB),
+  CodeBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.Nl),
+  ContainerBlock: () => (/* reexport safe */ _blocks__rspack_import_0.j7),
+  FunctionBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.kF),
+  FunctionFactoryBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.O_),
+  IfBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.Zm),
+  ObjectBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.Tl),
+  RawBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.qY),
+  SlotBlock: () => (/* reexport safe */ _blocks__rspack_import_0.E2),
+  StringBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.fe),
+  VariableBuilder: () => (/* reexport safe */ _blocks__rspack_import_0.ot)
+});
+/* import */ var _blocks__rspack_import_0 = __webpack_require__(980);
+
+
+
+})();
+
+module.exports = __webpack_exports__;
+})()
+;
+//# sourceMappingURL=index.cjs.map