@effected/toml 0.1.0

package/TomlNode.js

@@ -0,0 +1,212 @@
+import { TomlLocalDate, TomlLocalDateTime, TomlLocalTime, TomlOffsetDateTime } from "./TomlDateTime.js";
+import { Schema } from "effect";
+
+//#region src/TomlNode.ts
+/**
+* The three simple-key spellings: `bare`, `basic` (`"..."`) and `literal`
+* (`'...'`).
+*
+* @public
+*/
+const TomlKeyKind = Schema.Literals([
+	"bare",
+	"basic",
+	"literal"
+]);
+/**
+* One simple key within a (possibly dotted) key path.
+*
+* - `value` — the decoded key text (escapes resolved, quotes stripped).
+* - `kind` — how the key was spelled in the source.
+* - `offset` / `length` — the key's span in the source, quotes included.
+*
+* @public
+*/
+var TomlKey = class extends Schema.TaggedClass()("TomlKey", {
+	value: Schema.String,
+	kind: TomlKeyKind,
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* The four TOML string forms.
+*
+* @public
+*/
+const TomlStringStyle = Schema.Literals([
+	"basic",
+	"literal",
+	"multiline-basic",
+	"multiline-literal"
+]);
+/**
+* A string value node. `value` is the decoded text; the raw spelling lives in
+* the source span.
+*
+* @public
+*/
+var TomlString = class extends Schema.TaggedClass()("TomlString", {
+	value: Schema.String,
+	style: TomlStringStyle,
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* An integer value node. Decodes to `number` when the magnitude fits in
+* 2^53 - 1, else `bigint` (TOML integers span the full signed 64-bit range).
+*
+* @public
+*/
+var TomlInteger = class extends Schema.TaggedClass()("TomlInteger", {
+	value: Schema.Union([Schema.Number, Schema.BigInt]),
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* A float value node, including the special spellings (`inf`, `nan`).
+*
+* @public
+*/
+var TomlFloat = class extends Schema.TaggedClass()("TomlFloat", {
+	value: Schema.Number,
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* A boolean value node.
+*
+* @public
+*/
+var TomlBoolean = class extends Schema.TaggedClass()("TomlBoolean", {
+	value: Schema.Boolean,
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* A date-time value node wrapping one of the four TOML date-time classes.
+*
+* @public
+*/
+var TomlDateTimeLiteral = class extends Schema.TaggedClass()("TomlDateTimeLiteral", {
+	value: Schema.Union([
+		TomlOffsetDateTime,
+		TomlLocalDateTime,
+		TomlLocalDate,
+		TomlLocalTime
+	]),
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* An array value node. Heterogeneous per TOML 1.0.0; may span multiple lines
+* (the span covers brackets, inner newlines and inner comments).
+*
+* @public
+*/
+var TomlArray = class extends Schema.TaggedClass()("TomlArray", {
+	items: Schema.Array(Schema.suspend(() => TomlValueNode)),
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* One `key = value` entry inside an inline table. `keyPath` has more than one
+* element for dotted keys (`{a.b = 1}`).
+*
+* @public
+*/
+var TomlInlineEntry = class extends Schema.TaggedClass()("TomlInlineEntry", {
+	keyPath: Schema.Array(TomlKey),
+	value: Schema.suspend(() => TomlValueNode),
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* An inline table value node (`{ k = v, ... }`). Single-line by grammar.
+*
+* @public
+*/
+var TomlInlineTable = class extends Schema.TaggedClass()("TomlInlineTable", {
+	entries: Schema.Array(TomlInlineEntry),
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* A discriminated-union schema covering all seven TOML value node types.
+* Defined lazily via `Schema.suspend` to break the recursive reference chain
+* `TomlValueNode → TomlArray/TomlInlineTable → TomlValueNode`.
+*
+* @public
+*/
+const TomlValueNode = Schema.suspend(() => Schema.Union([
+	TomlString,
+	TomlInteger,
+	TomlFloat,
+	TomlBoolean,
+	TomlDateTimeLiteral,
+	TomlArray,
+	TomlInlineTable
+]));
+/**
+* A `key = value` expression. The span starts at the first character of the
+* line's leading whitespace and ends after the terminating newline (or at
+* EOF); multi-line values extend it. `comment` holds the decoded trailing
+* comment (without `#`, one leading space stripped) when present.
+*
+* @public
+*/
+var TomlKeyValue = class extends Schema.TaggedClass()("TomlKeyValue", {
+	keyPath: Schema.Array(TomlKey),
+	value: Schema.suspend(() => TomlValueNode),
+	comment: Schema.optionalKey(Schema.String),
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* A `[table]` header expression. Span contract as in {@link TomlKeyValue}.
+*
+* @public
+*/
+var TomlTableHeader = class extends Schema.TaggedClass()("TomlTableHeader", {
+	keyPath: Schema.Array(TomlKey),
+	comment: Schema.optionalKey(Schema.String),
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* A `[[array-of-tables]]` header expression. Span contract as in
+* {@link TomlKeyValue}.
+*
+* @public
+*/
+var TomlArrayTableHeader = class extends Schema.TaggedClass()("TomlArrayTableHeader", {
+	keyPath: Schema.Array(TomlKey),
+	comment: Schema.optionalKey(Schema.String),
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* A run of consecutive blank and comment-only lines, coalesced into one
+* expression. `text` is the raw source slice, newlines included.
+*
+* @public
+*/
+var TomlTrivia = class extends Schema.TaggedClass()("TomlTrivia", {
+	text: Schema.String,
+	offset: Schema.Number,
+	length: Schema.Number
+}) {};
+/**
+* The union schema of the four expression types making up a document's
+* linear CST.
+*
+* @public
+*/
+const TomlExpression = Schema.Union([
+	TomlKeyValue,
+	TomlTableHeader,
+	TomlArrayTableHeader,
+	TomlTrivia
+]);
+
+//#endregion
+export { TomlArray, TomlArrayTableHeader, TomlBoolean, TomlDateTimeLiteral, TomlExpression, TomlFloat, TomlInlineEntry, TomlInlineTable, TomlInteger, TomlKey, TomlKeyKind, TomlKeyValue, TomlString, TomlStringStyle, TomlTableHeader, TomlTrivia, TomlValueNode };

package/TomlVisitor.js

@@ -0,0 +1,152 @@
+import { isRawTomlError } from "./internal/diagnostics.js";
+import { isGuardExceeded } from "./internal/limits.js";
+import { TomlKeyValue, TomlTrivia } from "./TomlNode.js";
+import { scanComment, scanNewline, scanWhitespace } from "./internal/scanner.js";
+import { parseExpressions } from "./internal/parser.js";
+import { analyze } from "./internal/semantic.js";
+import { TomlDiagnostic } from "./TomlDiagnostic.js";
+import { TomlParseError } from "./Toml.js";
+import { Data, Effect, Stream } from "effect";
+
+//#region src/TomlVisitor.ts
+/**
+* Constructors and matchers for the `TomlVisitorEvent` union (e.g.
+* `TomlVisitorEvent.KeyValue({ path, node })`, `TomlVisitorEvent.$is("Comment")`).
+*
+* @public
+*/
+const TomlVisitorEvent = Data.taggedEnum();
+/** Decoded trailing-comment text: the raw text after `#` with one leading space stripped (mirrors internal/parser.ts). */
+const decodeCommentText = (raw) => raw.startsWith(" ") ? raw.slice(1) : raw;
+/**
+* Locate the `#` starting a trailing comment already known to exist
+* (`comment !== undefined`). Search begins after the last span that can
+* itself contain a `#` character — the value span for a key-value, the last
+* key span for a header — so the first `#` found is unambiguously the
+* comment marker.
+*/
+const trailingCommentOffset = (source, expression) => {
+	if (expression instanceof TomlKeyValue) return source.indexOf("#", expression.value.offset + expression.value.length);
+	const lastKey = expression.keyPath[expression.keyPath.length - 1];
+	return source.indexOf("#", lastKey.offset + lastKey.length);
+};
+/** Standalone comments inside a trivia run, each positioned by its `#`'s absolute offset. */
+const collectTriviaComments = (trivia) => {
+	const events = [];
+	const text = trivia.text;
+	let pos = 0;
+	while (pos < text.length) {
+		const i = scanWhitespace(text, pos);
+		if (text.charAt(i) === "#") {
+			const scanned = scanComment(text, i);
+			const offset = trivia.offset + i;
+			events.push({
+				offset,
+				event: TomlVisitorEvent.Comment({
+					text: decodeCommentText(scanned.value),
+					offset
+				})
+			});
+			pos = scanned.end < text.length ? scanNewline(text, scanned.end) : scanned.end;
+		} else pos = i < text.length ? scanNewline(text, i) : i;
+	}
+	return events;
+};
+/**
+* Parse, run the semantic pass collecting its callbacks as positioned events,
+* collect comment events from the same expression array, then merge both by
+* offset. Throws the engine's raw carriers on malformed/adversarial input —
+* caught and materialized by the caller, exactly like `Toml.parse`.
+*/
+const collectEvents = (text) => {
+	const expressions = parseExpressions(text);
+	const positioned = [];
+	analyze(expressions, {
+		onTableStart: (path, header) => {
+			positioned.push({
+				offset: header?.offset ?? -1,
+				event: TomlVisitorEvent.TableStart({ path })
+			});
+		},
+		onArrayTableStart: (path, index, header) => {
+			positioned.push({
+				offset: header.offset,
+				event: TomlVisitorEvent.ArrayTableStart({
+					path,
+					index
+				})
+			});
+		},
+		onKeyValue: (path, node) => {
+			positioned.push({
+				offset: node.offset,
+				event: TomlVisitorEvent.KeyValue({
+					path,
+					node
+				})
+			});
+		}
+	});
+	for (const expression of expressions) {
+		if (expression instanceof TomlTrivia) {
+			positioned.push(...collectTriviaComments(expression));
+			continue;
+		}
+		if (expression.comment !== void 0) {
+			const offset = trailingCommentOffset(text, expression);
+			positioned.push({
+				offset,
+				event: TomlVisitorEvent.Comment({
+					text: expression.comment,
+					offset
+				})
+			});
+		}
+	}
+	positioned.sort((a, b) => a.offset - b.offset);
+	return positioned.map((positionedEvent) => positionedEvent.event);
+};
+/**
+* Run `collectEvents`, materializing the engine's raw carriers into
+* {@link TomlParseError} exactly like `Toml.parse` — a lex/parse error and a
+* semantic-pass error (e.g. `DuplicateKey`) both fail the same way.
+*/
+const collectEventsOrFail = (text) => Effect.try({
+	try: () => collectEvents(text),
+	catch: (defect) => {
+		if (isRawTomlError(defect)) return new TomlParseError({ diagnostics: [TomlDiagnostic.fromRaw(text, defect.diagnostic)] });
+		if (isGuardExceeded(defect)) return new TomlParseError({ diagnostics: [TomlDiagnostic.fromRaw(text, {
+			code: "NestingDepthExceeded",
+			message: defect.message,
+			offset: defect.offset,
+			length: 0
+		})] });
+		throw defect;
+	}
+});
+/**
+* SAX-style TOML visitor statics. Not instantiable.
+*
+* @public
+*/
+var TomlVisitor = class {
+	constructor() {}
+	/**
+	* Create a `Stream` of `TomlVisitorEvent` from TOML text, in document
+	* order. Fails the stream with {@link TomlParseError} on the first
+	* lex/parse or semantic violation — never as an unhandled defect.
+	*
+	* @remarks
+	* Construction is eager, not on-demand: the full text is parsed, walked by
+	* `analyze` and sorted into document order up front, inside the `Effect`
+	* `Stream.unwrap` runs to build the stream. Only enumeration of the
+	* already-built event array is streamed — `Stream.take` still short-circuits
+	* consumption, but it does not avoid the initial parse/analyze/sort pass.
+	*/
+	static visit(text) {
+		return Stream.unwrap(collectEventsOrFail(text).pipe(Effect.map(Stream.fromIterable)));
+	}
+};
+
+//#endregion
+export { TomlVisitor, TomlVisitorEvent };