@shipworthy/openapi-parser 0.0.0-stage → 0.0.1

package/dist/yaml.js

@@ -0,0 +1,235 @@
+import * as Yaml from "effect/encoding/Yaml";
+const blockScalar = /^[|>](?:[1-9]?[+-]?|[+-]?[1-9]?)$/;
+/**
+ * Effect's YAML decoder rejects `- - value` and treats `<<` as a normal key.
+ * OpenAPI fixtures in this repo use both, so expand those forms before parsing.
+ */
+export function parseYamlDocument(source) {
+    const text = source.charCodeAt(0) === 0xfeff ? source.slice(1) : source;
+    if (text.trim().length === 0)
+        return null;
+    return applyMergeKeys(Yaml.parse(expandCompactNestedSequences(deepenShallowBlockScalars(relaxIndentTabs(text)))));
+}
+/**
+ * Effect closes a block scalar when the next line is not indented past the header.
+ * `- |2` followed by text at the same column is that case. Indent the content and
+ * drop the explicit indicator so auto-detection keeps the scalar text.
+ */
+function deepenShallowBlockScalars(source) {
+    const lines = source.replace(/\r\n?/g, "\n").split("\n");
+    const output = [];
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index] ?? "";
+        const indent = leadingSpaces(line);
+        const text = stripComment(line.slice(indent)).trimEnd();
+        if (!isExplicitBlockScalar(text) || !hasShallowContent(lines, index, indent)) {
+            output.push(line);
+            continue;
+        }
+        output.push(dropExplicitIndent(line));
+        index++;
+        while (index < lines.length) {
+            const next = lines[index] ?? "";
+            if (next.trim().length > 0 && leadingSpaces(next) < indent)
+                break;
+            output.push(next.trim().length === 0 ? next : `  ${next}`);
+            index++;
+        }
+        index--;
+    }
+    return output.join("\n");
+}
+function isExplicitBlockScalar(text) {
+    return /^[|>](?:[+-]?[1-9]|[1-9][+-])$/.test(scalarToken(text));
+}
+function scalarToken(text) {
+    const separator = mappingSeparator(text);
+    const token = separator === -1 ? text : text.slice(separator + 1).trim();
+    if (token === "-" || token.startsWith("- ")) {
+        const item = token.slice(1).trimStart();
+        const nested = mappingSeparator(item);
+        return nested === -1 ? item : item.slice(nested + 1).trim();
+    }
+    return token;
+}
+function hasShallowContent(lines, header, indent) {
+    for (let index = header + 1; index < lines.length; index++) {
+        const line = lines[index] ?? "";
+        if (line.trim().length === 0)
+            continue;
+        return leadingSpaces(line) <= indent;
+    }
+    return false;
+}
+function dropExplicitIndent(line) {
+    return line.replace(/([|>])(\+|-)?[1-9](\+|-)?(\s*(?:#.*)?)?$/, (_, bar, before, after, tail) => `${bar}${before ?? ""}${after ?? ""}${tail ?? ""}`);
+}
+/** Effect rejects a tab after leading spaces, including inside block scalars. */
+function relaxIndentTabs(source) {
+    return source.replace(/^( *)\t+/gm, (match, spaces) => spaces + "  ".repeat(match.length - spaces.length));
+}
+export function expandCompactNestedSequences(source) {
+    const lines = source
+        .replace(/^\uFEFF/, "")
+        .replace(/\r\n?/g, "\n")
+        .split("\n");
+    const output = [];
+    let blockIndent = -1;
+    for (const line of lines) {
+        let raw = line;
+        while (true) {
+            const indent = leadingSpaces(raw);
+            if (blockIndent >= 0) {
+                if (raw.trim().length > 0 && indent <= blockIndent)
+                    blockIndent = -1;
+                else
+                    break;
+            }
+            const text = stripComment(raw.slice(indent)).trimEnd();
+            const compact = compactRest(raw, indent);
+            if (compact === undefined) {
+                if (isBlockScalar(text))
+                    blockIndent = indent;
+                break;
+            }
+            output.push(`${" ".repeat(indent)}-`);
+            raw = `${" ".repeat(indent + 2)}${compact}`;
+        }
+        output.push(raw);
+    }
+    return output.join("\n");
+}
+function compactRest(raw, indent) {
+    const body = raw.slice(indent);
+    if (!body.startsWith("- "))
+        return undefined;
+    const rest = body.slice(2);
+    const text = stripComment(rest).trimEnd();
+    if (text === "-" || text.startsWith("- "))
+        return rest;
+    return undefined;
+}
+function isBlockScalar(text) {
+    if (blockScalar.test(text))
+        return true;
+    const separator = mappingSeparator(text);
+    if (separator !== -1)
+        return blockScalar.test(text.slice(separator + 1).trim());
+    if (text === "-" || text.startsWith("- ")) {
+        const item = text.slice(1).trimStart();
+        const nested = mappingSeparator(item);
+        if (nested === -1)
+            return blockScalar.test(item);
+        return blockScalar.test(item.slice(nested + 1).trim());
+    }
+    return false;
+}
+function applyMergeKeys(value, seen = new Set()) {
+    if (typeof value !== "object" || value === null || seen.has(value))
+        return value;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index++)
+            value[index] = applyMergeKeys(value[index], seen);
+        return value;
+    }
+    const record = value;
+    for (const key of Object.keys(record))
+        record[key] = applyMergeKeys(record[key], seen);
+    if (!Object.keys(record).some(isMergeKey))
+        return record;
+    const next = {};
+    for (const key of Object.keys(record)) {
+        if (!isMergeKey(key)) {
+            next[key] = record[key];
+            continue;
+        }
+        const source = record[key];
+        const entries = Array.isArray(source) ? source : [source];
+        for (const entry of entries) {
+            if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+                continue;
+            for (const [mergedKey, mergedValue] of Object.entries(entry)) {
+                if (isMergeKey(mergedKey) || Object.hasOwn(next, mergedKey))
+                    continue;
+                next[mergedKey] = mergedValue;
+            }
+        }
+    }
+    for (const key of Object.keys(record))
+        delete record[key];
+    Object.assign(record, next);
+    return record;
+}
+function isMergeKey(key) {
+    const text = key.trim();
+    return text === "<<" || /^!!\S+\s+<<$/.test(text) || /^!<[^>]+>\s+<<$/.test(text);
+}
+function leadingSpaces(raw) {
+    let index = 0;
+    while (raw.charCodeAt(index) === 32)
+        index++;
+    return index;
+}
+const closingQuote = (input, quote, start) => {
+    for (let index = start; index < input.length; index++) {
+        const character = input[index];
+        if (quote === '"' && character === "\\")
+            index++;
+        else if (character === quote) {
+            if (quote === "'" && input[index + 1] === quote)
+                index++;
+            else
+                return index;
+        }
+    }
+    return -1;
+};
+const findIndicator = (input, indicator) => {
+    let depth = 0;
+    let tokenStart = true;
+    for (let index = 0; index < input.length; index++) {
+        const character = input[index];
+        if (tokenStart && (character === "'" || character === '"')) {
+            index = closingQuote(input, character, index + 1);
+            if (index === -1)
+                return -1;
+            tokenStart = false;
+        }
+        else if (tokenStart && character === "&") {
+            while (index + 1 < input.length && !/[\s,[\]{}]/.test(input[index + 1] ?? ""))
+                index++;
+        }
+        else if (character === "#" && (index === 0 || /\s/.test(input[index - 1] ?? ""))) {
+            return indicator === "#" ? index : -1;
+        }
+        else if (tokenStart && (character === "[" || character === "{")) {
+            depth++;
+        }
+        else if (depth > 0 && (character === "]" || character === "}")) {
+            depth--;
+            tokenStart = false;
+        }
+        else if (depth > 0 && character === ",") {
+            tokenStart = true;
+        }
+        else if (character === ":" &&
+            (depth > 0 || input[index + 1] === undefined || /\s/.test(input[index + 1] ?? ""))) {
+            if (depth === 0 && indicator === ":")
+                return index;
+            tokenStart = true;
+        }
+        else if (tokenStart && character === "-" && /\s/.test(input[index + 1] ?? "")) {
+            continue;
+        }
+        else if (!/\s/.test(character ?? "")) {
+            tokenStart = false;
+        }
+    }
+    return -1;
+};
+const stripComment = (input) => {
+    const index = findIndicator(input, "#");
+    return index === -1 ? input : input.slice(0, index).trimEnd();
+};
+const mappingSeparator = (input) => findIndicator(input, ":");

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@shipworthy/openapi-parser",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@effect/platform-node": "^4.0.0"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.0"
+  },
+  "description": "Parse, bundle, and upgrade OpenAPI documents with Effect schemas.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShipWorthyAI/openapi.git",
+    "directory": "packages/openapi-parser"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./schemas/3.1": {
+      "types": "./dist/schemas/3.1/index.d.ts",
+      "default": "./dist/schemas/3.1/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0",
+    "@shipworthy/typescript-config": "0.0.1",
+    "@types/node": "^24.10.3",
+    "effect": "^4.0.0",
+    "typescript": "^7.0.2",
+    "vitest": "5.0.3"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  }
+}