@aerobuilt/interpolation 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 James M. Wilson (Aerobuilt)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared tokenizer for `{ }` interpolation. Tracks brace depth and string/comment
+ * context so nested braces and content inside strings/comments are handled correctly.
+ *
+ * @remarks
+ * Used by @aerobuilt/core (compileInterpolation, compileAttributeInterpolation) and
+ * can be used by aero-vscode for consistent interpolation semantics.
+ */
+type LiteralSegment = {
+    kind: 'literal';
+    start: number;
+    end: number;
+    value: string;
+};
+type InterpolationSegment = {
+    kind: 'interpolation';
+    start: number;
+    end: number;
+    expression: string;
+};
+type Segment = LiteralSegment | InterpolationSegment;
+interface TokenizeOptions {
+    /** When true, `{{` and `}}` emit literal `{` and `}`; otherwise they are two braces. */
+    attributeMode?: boolean;
+}
+/**
+ * Tokenize a string into literal and interpolation segments. Tracks nesting and
+ * string/comment context so expressions like `{ a({ b: 1 }) }` or `{ "}" }` are
+ * one interpolation.
+ *
+ * @param text - Input string (e.g. attribute value or text content).
+ * @param options - `attributeMode: true` for attribute values ({{ / }} = literal braces).
+ * @returns Array of segments in order.
+ */
+declare function tokenizeCurlyInterpolation(text: string, options?: TokenizeOptions): Segment[];
+/**
+ * Build a template-literal-safe string from segments: escape backticks in literal
+ * segments and emit `${expression}` for interpolations.
+ *
+ * @param segments - Output from tokenizeCurlyInterpolation.
+ * @returns String safe to embed inside a template literal (backticks).
+ */
+declare function compileInterpolationFromSegments(segments: Segment[]): string;
+
+export { type InterpolationSegment, type LiteralSegment, type Segment, type TokenizeOptions, compileInterpolationFromSegments, tokenizeCurlyInterpolation };

package/dist/index.js

@@ -0,0 +1,127 @@
+// src/index.ts
+function tokenizeCurlyInterpolation(text, options = {}) {
+  const attributeMode = options.attributeMode ?? false;
+  const segments = [];
+  let i = 0;
+  let depth = 0;
+  let literalStart = 0;
+  let interpOpenIndex = -1;
+  let interpExprStart = -1;
+  let inString = null;
+  let inComment = null;
+  function pushLiteral(from, to) {
+    if (from < to) {
+      segments.push({
+        kind: "literal",
+        start: from,
+        end: to,
+        value: text.slice(from, to)
+      });
+    }
+  }
+  function pushInterpolation(openIndex, closeIndex) {
+    segments.push({
+      kind: "interpolation",
+      start: openIndex,
+      end: closeIndex + 1,
+      expression: text.slice(openIndex + 1, closeIndex)
+    });
+  }
+  while (i < text.length) {
+    const char = text[i];
+    const next = text[i + 1];
+    if (inComment) {
+      if (inComment === "//" && char === "\n") {
+        inComment = null;
+      } else if (inComment === "/*" && char === "*" && next === "/") {
+        inComment = null;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (inString) {
+      if (char === "\\") {
+        i++;
+      } else if (char === inString) {
+        inString = null;
+      }
+      i++;
+      continue;
+    }
+    if (attributeMode && depth === 0) {
+      if (char === "{" && next === "{") {
+        pushLiteral(literalStart, i);
+        segments.push({ kind: "literal", start: i, end: i + 2, value: "{" });
+        literalStart = i + 2;
+        i += 2;
+        continue;
+      }
+      if (char === "}" && next === "}") {
+        pushLiteral(literalStart, i);
+        segments.push({ kind: "literal", start: i, end: i + 2, value: "}" });
+        literalStart = i + 2;
+        i += 2;
+        continue;
+      }
+    }
+    if (char === "/" && next === "/") {
+      inComment = "//";
+      i += 2;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      inComment = "/*";
+      i += 2;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      i++;
+      continue;
+    }
+    if (char === "{") {
+      if (depth === 0) {
+        pushLiteral(literalStart, i);
+        interpOpenIndex = i;
+        interpExprStart = i + 1;
+      }
+      depth++;
+      i++;
+      continue;
+    }
+    if (char === "}") {
+      depth--;
+      if (depth === 0) {
+        pushInterpolation(interpOpenIndex, i);
+        literalStart = i + 1;
+      }
+      i++;
+      continue;
+    }
+    i++;
+  }
+  if (depth > 0) {
+    segments.push({
+      kind: "interpolation",
+      start: interpOpenIndex,
+      end: text.length,
+      expression: text.slice(interpExprStart, text.length)
+    });
+    literalStart = text.length;
+  }
+  pushLiteral(literalStart, text.length);
+  return segments;
+}
+function compileInterpolationFromSegments(segments) {
+  return segments.map((seg) => {
+    if (seg.kind === "literal") {
+      return seg.value.replace(/`/g, "\\`");
+    }
+    return `\${${seg.expression}}`;
+  }).join("");
+}
+export {
+  compileInterpolationFromSegments,
+  tokenizeCurlyInterpolation
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@aerobuilt/interpolation",
+  "version": "0.2.2",
+  "type": "module",
+  "license": "MIT",
+  "author": "Jamie Wilson",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aerobuilt/aero.git",
+    "directory": "packages/interpolation"
+  },
+  "homepage": "https://github.com/aerobuilt/aero",
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --out-dir dist",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}