@aliou/obsdx-base-ast 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,101 @@
+//#region src/expressions/ast.d.ts
+type Expr = {
+  kind: "literal";
+  value: unknown;
+} | {
+  kind: "regex";
+  pattern: string;
+  flags: string;
+} | {
+  kind: "array";
+  elements: Expr[];
+} | {
+  kind: "identifier";
+  name: string;
+} | {
+  kind: "member";
+  object: Expr;
+  property: string;
+} | {
+  kind: "index";
+  object: Expr;
+  index: Expr;
+} | {
+  kind: "call";
+  callee: Expr;
+  args: Expr[];
+} | {
+  kind: "unary";
+  operator: "!" | "-";
+  right: Expr;
+} | {
+  kind: "binary";
+  left: Expr;
+  operator: string;
+  right: Expr;
+};
+//#endregion
+//#region src/expressions/lexer.d.ts
+type TokenType = "identifier" | "number" | "string" | "regex" | "operator" | "punct" | "eof";
+type Token = {
+  type: TokenType;
+  lexeme: string;
+  value?: unknown;
+};
+declare function lexExpression(source: string): Token[];
+//#endregion
+//#region src/expressions/parser.d.ts
+declare function parseExpression(source: string): Expr;
+//#endregion
+//#region src/filter.d.ts
+type FilterNode = {
+  op: "expr";
+  expression: unknown;
+} | {
+  op: "and";
+  children: FilterNode[];
+} | {
+  op: "or";
+  children: FilterNode[];
+} | {
+  op: "not";
+  children: FilterNode[];
+};
+//#endregion
+//#region src/parser.d.ts
+type BasePropertyConfig = {
+  displayName?: string;
+};
+type BaseSort = {
+  property: string;
+  direction?: "ASC" | "DESC";
+};
+type BaseGroupBy = {
+  property: string;
+  direction?: "ASC" | "DESC";
+};
+type BaseView = {
+  type: string;
+  name: string;
+  filters?: unknown;
+  order?: string[];
+  sort?: BaseSort[];
+  limit?: number;
+  groupBy?: BaseGroupBy;
+  summaries?: Record<string, unknown>;
+  raw: Record<string, unknown>;
+};
+type BaseDefinition = {
+  path: string;
+  source: Record<string, unknown>;
+  properties: Record<string, BasePropertyConfig>;
+  formulas: Record<string, string>;
+  filters?: unknown;
+  summaries?: Record<string, string>;
+  views: BaseView[];
+};
+declare function parseBase(path: string, source: string): BaseDefinition;
+declare function validateBase(base: BaseDefinition): string[];
+//#endregion
+export { type BaseDefinition, type BaseGroupBy, type BasePropertyConfig, type BaseSort, type BaseView, type Expr, type FilterNode, type Token, type TokenType, lexExpression, parseBase, parseExpression, validateBase };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,453 @@
+import YAML from "yaml";
+//#region src/expressions/lexer.ts
+const OPERATORS = [
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"&&",
+	"||"
+];
+const SINGLE = new Set([
+	"!",
+	"<",
+	">",
+	"+",
+	"-",
+	"*",
+	"%"
+]);
+const PUNCT = new Set([
+	"(",
+	")",
+	"[",
+	"]",
+	".",
+	","
+]);
+function lexExpression(source) {
+	const tokens = [];
+	let index = 0;
+	while (index < source.length) {
+		const char = source[index] ?? "";
+		if (/\s/u.test(char)) {
+			index += 1;
+			continue;
+		}
+		const two = source.slice(index, index + 2);
+		if (OPERATORS.includes(two)) {
+			tokens.push({
+				type: "operator",
+				lexeme: two
+			});
+			index += 2;
+			continue;
+		}
+		if (SINGLE.has(char)) {
+			tokens.push({
+				type: "operator",
+				lexeme: char
+			});
+			index += 1;
+			continue;
+		}
+		if (PUNCT.has(char)) {
+			tokens.push({
+				type: "punct",
+				lexeme: char
+			});
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			const parsed = readString(source, index, char);
+			tokens.push({
+				type: "string",
+				lexeme: parsed.raw,
+				value: parsed.value
+			});
+			index = parsed.next;
+			continue;
+		}
+		if (char === "/") {
+			if (expectsOperand(tokens[tokens.length - 1])) {
+				const parsed = readRegex(source, index);
+				tokens.push({
+					type: "regex",
+					lexeme: parsed.raw,
+					value: parsed.value
+				});
+				index = parsed.next;
+				continue;
+			}
+			tokens.push({
+				type: "operator",
+				lexeme: "/"
+			});
+			index += 1;
+			continue;
+		}
+		if (/\d/u.test(char)) {
+			const match = source.slice(index).match(/^\d+(?:\.\d+)?/u);
+			if (match) {
+				tokens.push({
+					type: "number",
+					lexeme: match[0],
+					value: Number(match[0])
+				});
+				index += match[0].length;
+				continue;
+			}
+		}
+		if (/[A-Za-z_]/u.test(char)) {
+			const match = source.slice(index).match(/^[A-Za-z_][A-Za-z0-9_-]*/u);
+			if (match) {
+				tokens.push({
+					type: "identifier",
+					lexeme: match[0]
+				});
+				index += match[0].length;
+				continue;
+			}
+		}
+		throw new Error(`Unexpected token near "${source.slice(index)}"`);
+	}
+	tokens.push({
+		type: "eof",
+		lexeme: ""
+	});
+	return tokens;
+}
+/**
+* Returns true if the previous token implies the next token should be
+* an operand (value), making a leading `/` a regex literal rather than
+* the division operator.
+*/
+function expectsOperand(prev) {
+	if (!prev || prev.type === "eof") return true;
+	if (prev.type === "operator") return true;
+	if (prev.type === "punct") return prev.lexeme === "(" || prev.lexeme === "[" || prev.lexeme === ",";
+	return false;
+}
+function readRegex(source, start) {
+	let index = start + 1;
+	let pattern = "";
+	let inCharClass = false;
+	while (index < source.length) {
+		const char = source[index] ?? "";
+		if (char === "\\") {
+			pattern += source.slice(index, index + 2);
+			index += 2;
+			continue;
+		}
+		if (char === "[") {
+			inCharClass = true;
+			pattern += char;
+			index += 1;
+			continue;
+		}
+		if (char === "]" && inCharClass) {
+			inCharClass = false;
+			pattern += char;
+			index += 1;
+			continue;
+		}
+		if (char === "/" && !inCharClass) {
+			const raw = source.slice(start, index + 1);
+			const flagStart = index + 1;
+			const flags = source.slice(flagStart).match(/^[gimsuy]*/u)?.[0] ?? "";
+			return {
+				raw: raw + flags,
+				value: {
+					pattern,
+					flags
+				},
+				next: flagStart + flags.length
+			};
+		}
+		pattern += char;
+		index += 1;
+	}
+	throw new Error("Unterminated regex literal");
+}
+function readString(source, start, quote) {
+	let value = "";
+	let index = start + 1;
+	while (index < source.length) {
+		const char = source[index] ?? "";
+		if (char === quote) return {
+			raw: source.slice(start, index + 1),
+			value,
+			next: index + 1
+		};
+		if (char === "\\") {
+			value += source[index + 1] ?? "";
+			index += 2;
+			continue;
+		}
+		value += char;
+		index += 1;
+	}
+	throw new Error("Unterminated string literal");
+}
+//#endregion
+//#region src/expressions/parser.ts
+const PRECEDENCE = new Map([
+	["||", 1],
+	["&&", 2],
+	["==", 3],
+	["!=", 3],
+	["<", 4],
+	["<=", 4],
+	[">", 4],
+	[">=", 4],
+	["+", 5],
+	["-", 5],
+	["*", 6],
+	["/", 6],
+	["%", 6]
+]);
+function parseExpression(source) {
+	return new Parser(lexExpression(source)).parse();
+}
+var Parser = class {
+	tokens;
+	#current = 0;
+	constructor(tokens) {
+		this.tokens = tokens;
+	}
+	parse() {
+		const expression = this.parseExpression(0);
+		this.consume("eof");
+		return expression;
+	}
+	parseExpression(minPrecedence) {
+		let left = this.parsePrefix();
+		while (this.peek().type === "operator") {
+			const operator = this.peek().lexeme;
+			const precedence = PRECEDENCE.get(operator);
+			if (precedence === void 0 || precedence < minPrecedence) break;
+			this.advance();
+			const right = this.parseExpression(precedence + 1);
+			left = {
+				kind: "binary",
+				left,
+				operator,
+				right
+			};
+		}
+		return left;
+	}
+	parsePrefix() {
+		if (this.match("operator", "!")) return {
+			kind: "unary",
+			operator: "!",
+			right: this.parsePrefix()
+		};
+		if (this.match("operator", "-")) return {
+			kind: "unary",
+			operator: "-",
+			right: this.parsePrefix()
+		};
+		return this.parsePostfix(this.parsePrimary());
+	}
+	parsePrimary() {
+		const token = this.advance();
+		if (token.type === "number" || token.type === "string") return {
+			kind: "literal",
+			value: token.value
+		};
+		if (token.type === "regex") {
+			const value = token.value;
+			return {
+				kind: "regex",
+				pattern: value.pattern,
+				flags: value.flags
+			};
+		}
+		if (token.type === "identifier") {
+			if (token.lexeme === "true") return {
+				kind: "literal",
+				value: true
+			};
+			if (token.lexeme === "false") return {
+				kind: "literal",
+				value: false
+			};
+			if (token.lexeme === "null") return {
+				kind: "literal",
+				value: null
+			};
+			return {
+				kind: "identifier",
+				name: token.lexeme
+			};
+		}
+		if (token.type === "punct" && token.lexeme === "[") {
+			const elements = [];
+			if (!this.check("punct", "]")) do
+				elements.push(this.parseExpression(0));
+			while (this.match("punct", ","));
+			this.consume("punct", "]");
+			return {
+				kind: "array",
+				elements
+			};
+		}
+		if (token.type === "punct" && token.lexeme === "(") {
+			const expression = this.parseExpression(0);
+			this.consume("punct", ")");
+			return expression;
+		}
+		throw new Error(`Expected expression near "${token.lexeme}"`);
+	}
+	parsePostfix(expression) {
+		let current = expression;
+		while (true) {
+			if (this.match("punct", ".")) {
+				const property = this.consume("identifier").lexeme;
+				current = {
+					kind: "member",
+					object: current,
+					property
+				};
+				continue;
+			}
+			if (this.match("punct", "[")) {
+				const index = this.parseExpression(0);
+				this.consume("punct", "]");
+				current = {
+					kind: "index",
+					object: current,
+					index
+				};
+				continue;
+			}
+			if (this.match("punct", "(")) {
+				const args = [];
+				if (!this.check("punct", ")")) do
+					args.push(this.parseExpression(0));
+				while (this.match("punct", ","));
+				this.consume("punct", ")");
+				current = {
+					kind: "call",
+					callee: current,
+					args
+				};
+				continue;
+			}
+			return current;
+		}
+	}
+	match(type, lexeme) {
+		if (!this.check(type, lexeme)) return false;
+		this.advance();
+		return true;
+	}
+	consume(type, lexeme) {
+		if (!this.check(type, lexeme)) throw new Error(`Expected ${lexeme ?? type}, got "${this.peek().lexeme}"`);
+		return this.advance();
+	}
+	check(type, lexeme) {
+		const token = this.peek();
+		return token.type === type && (lexeme === void 0 || token.lexeme === lexeme);
+	}
+	advance() {
+		const token = this.peek();
+		this.#current += 1;
+		return token;
+	}
+	peek() {
+		return this.tokens[this.#current] ?? {
+			type: "eof",
+			lexeme: ""
+		};
+	}
+};
+//#endregion
+//#region src/parser.ts
+function parseBase(path, source) {
+	const parsed = YAML.parse(source);
+	if (!isRecord(parsed)) throw new Error("Base file must contain a YAML object");
+	return {
+		path,
+		source: parsed,
+		properties: parseProperties(parsed.properties),
+		formulas: parseFormulas(parsed.formulas),
+		filters: parsed.filters,
+		summaries: parseSummaries(parsed.summaries),
+		views: parseViews(parsed.views)
+	};
+}
+function validateBase(base) {
+	const errors = [];
+	if (!Array.isArray(base.source.views)) errors.push("views must be a list");
+	for (const [index, view] of base.views.entries()) {
+		if (!view.name) errors.push(`views[${index}].name is required`);
+		if (!view.type) errors.push(`views[${index}].type is required`);
+	}
+	return errors;
+}
+function parseProperties(value) {
+	if (!isRecord(value)) return {};
+	const properties = {};
+	for (const [name, config] of Object.entries(value)) properties[name] = isRecord(config) ? { displayName: stringValue(config.displayName) } : {};
+	return properties;
+}
+function parseFormulas(value) {
+	if (!isRecord(value)) return {};
+	const formulas = {};
+	for (const [name, formula] of Object.entries(value)) formulas[name] = String(formula);
+	return formulas;
+}
+function parseSummaries(value) {
+	if (!isRecord(value)) return;
+	const summaries = {};
+	for (const [name, formula] of Object.entries(value)) summaries[name] = String(formula);
+	return summaries;
+}
+function parseViews(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter(isRecord).map((view) => ({
+		type: stringValue(view.type) ?? "table",
+		name: stringValue(view.name) ?? "",
+		filters: view.filters,
+		order: Array.isArray(view.order) ? view.order.map(String) : void 0,
+		sort: parseSort(view.sort),
+		limit: typeof view.limit === "number" ? view.limit : void 0,
+		groupBy: parseGroupBy(view.groupBy),
+		summaries: isRecord(view.summaries) ? view.summaries : void 0,
+		raw: view
+	}));
+}
+function parseGroupBy(value) {
+	if (!isRecord(value)) return;
+	const property = stringValue(value.property);
+	if (!property) return;
+	return {
+		property,
+		direction: value.direction === "DESC" ? "DESC" : "ASC"
+	};
+}
+function parseSort(value) {
+	if (!Array.isArray(value)) return;
+	const sort = value.filter(isRecord).flatMap((item) => {
+		const property = stringValue(item.property);
+		if (!property) return [];
+		return [{
+			property,
+			direction: item.direction === "DESC" ? "DESC" : "ASC"
+		}];
+	});
+	return sort.length > 0 ? sort : void 0;
+}
+function stringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { lexExpression, parseBase, parseExpression, validateBase };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["#current"],"sources":["../src/expressions/lexer.ts","../src/expressions/parser.ts","../src/parser.ts"],"sourcesContent":["export type TokenType =\n  | \"identifier\"\n  | \"number\"\n  | \"string\"\n  | \"regex\"\n  | \"operator\"\n  | \"punct\"\n  | \"eof\";\n\nexport type Token = {\n  type: TokenType;\n  lexeme: string;\n  value?: unknown;\n};\n\nconst OPERATORS = [\"==\", \"!=\", \"<=\", \">=\", \"&&\", \"||\"] as const;\nconst SINGLE = new Set([\"!\", \"<\", \">\", \"+\", \"-\", \"*\", \"%\"]);\nconst PUNCT = new Set([\"(\", \")\", \"[\", \"]\", \".\", \",\"]);\n\nexport function lexExpression(source: string): Token[] {\n  const tokens: Token[] = [];\n  let index = 0;\n\n  while (index < source.length) {\n    const char = source[index] ?? \"\";\n    if (/\\s/u.test(char)) {\n      index += 1;\n      continue;\n    }\n\n    const two = source.slice(index, index + 2);\n    if (OPERATORS.includes(two as (typeof OPERATORS)[number])) {\n      tokens.push({ type: \"operator\", lexeme: two });\n      index += 2;\n      continue;\n    }\n\n    if (SINGLE.has(char)) {\n      tokens.push({ type: \"operator\", lexeme: char });\n      index += 1;\n      continue;\n    }\n\n    if (PUNCT.has(char)) {\n      tokens.push({ type: \"punct\", lexeme: char });\n      index += 1;\n      continue;\n    }\n\n    if (char === '\"' || char === \"'\") {\n      const parsed = readString(source, index, char);\n      tokens.push({ type: \"string\", lexeme: parsed.raw, value: parsed.value });\n      index = parsed.next;\n      continue;\n    }\n\n    // Regex literal vs division disambiguation:\n    // / is a regex start when we expect an operand (beginning of expression,\n    // after an operator, or after opening/separator punctuation).\n    // Otherwise / is the division operator.\n    if (char === \"/\") {\n      if (expectsOperand(tokens[tokens.length - 1])) {\n        const parsed = readRegex(source, index);\n        tokens.push({\n          type: \"regex\",\n          lexeme: parsed.raw,\n          value: parsed.value,\n        });\n        index = parsed.next;\n        continue;\n      }\n\n      tokens.push({ type: \"operator\", lexeme: \"/\" });\n      index += 1;\n      continue;\n    }\n\n    if (/\\d/u.test(char)) {\n      const match = source.slice(index).match(/^\\d+(?:\\.\\d+)?/u);\n      if (match) {\n        tokens.push({\n          type: \"number\",\n          lexeme: match[0],\n          value: Number(match[0]),\n        });\n        index += match[0].length;\n        continue;\n      }\n    }\n\n    if (/[A-Za-z_]/u.test(char)) {\n      const match = source.slice(index).match(/^[A-Za-z_][A-Za-z0-9_-]*/u);\n      if (match) {\n        tokens.push({ type: \"identifier\", lexeme: match[0] });\n        index += match[0].length;\n        continue;\n      }\n    }\n\n    throw new Error(`Unexpected token near \"${source.slice(index)}\"`);\n  }\n\n  tokens.push({ type: \"eof\", lexeme: \"\" });\n  return tokens;\n}\n\n/**\n * Returns true if the previous token implies the next token should be\n * an operand (value), making a leading `/` a regex literal rather than\n * the division operator.\n */\nfunction expectsOperand(prev?: Token): boolean {\n  if (!prev || prev.type === \"eof\") return true;\n  if (prev.type === \"operator\") return true;\n  if (prev.type === \"punct\") {\n    return prev.lexeme === \"(\" || prev.lexeme === \"[\" || prev.lexeme === \",\";\n  }\n  return false;\n}\n\nfunction readRegex(\n  source: string,\n  start: number,\n): { raw: string; value: { pattern: string; flags: string }; next: number } {\n  let index = start + 1; // skip opening /\n  let pattern = \"\";\n  let inCharClass = false;\n\n  while (index < source.length) {\n    const char = source[index] ?? \"\";\n\n    if (char === \"\\\\\") {\n      // Escaped character inside regex -- consume both the backslash and\n      // the following character so \\/ does not terminate the pattern.\n      pattern += source.slice(index, index + 2);\n      index += 2;\n      continue;\n    }\n\n    if (char === \"[\") {\n      inCharClass = true;\n      pattern += char;\n      index += 1;\n      continue;\n    }\n\n    if (char === \"]\" && inCharClass) {\n      inCharClass = false;\n      pattern += char;\n      index += 1;\n      continue;\n    }\n\n    if (char === \"/\" && !inCharClass) {\n      // Closing delimiter found.\n      const raw = source.slice(start, index + 1);\n\n      // Read optional flags after the closing /.\n      const flagStart = index + 1;\n      const flagMatch = source.slice(flagStart).match(/^[gimsuy]*/u);\n      const flags = flagMatch?.[0] ?? \"\";\n\n      return {\n        raw: raw + flags,\n        value: { pattern, flags },\n        next: flagStart + flags.length,\n      };\n    }\n\n    pattern += char;\n    index += 1;\n  }\n\n  throw new Error(\"Unterminated regex literal\");\n}\n\nfunction readString(\n  source: string,\n  start: number,\n  quote: string,\n): { raw: string; value: string; next: number } {\n  let value = \"\";\n  let index = start + 1;\n\n  while (index < source.length) {\n    const char = source[index] ?? \"\";\n    if (char === quote) {\n      return {\n        raw: source.slice(start, index + 1),\n        value,\n        next: index + 1,\n      };\n    }\n\n    if (char === \"\\\\\") {\n      value += source[index + 1] ?? \"\";\n      index += 2;\n      continue;\n    }\n\n    value += char;\n    index += 1;\n  }\n\n  throw new Error(\"Unterminated string literal\");\n}\n","import type { Expr } from \"./ast\";\nimport { lexExpression, type Token } from \"./lexer\";\n\nconst PRECEDENCE = new Map([\n  [\"||\", 1],\n  [\"&&\", 2],\n  [\"==\", 3],\n  [\"!=\", 3],\n  [\"<\", 4],\n  [\"<=\", 4],\n  [\">\", 4],\n  [\">=\", 4],\n  [\"+\", 5],\n  [\"-\", 5],\n  [\"*\", 6],\n  [\"/\", 6],\n  [\"%\", 6],\n]);\n\nexport function parseExpression(source: string): Expr {\n  return new Parser(lexExpression(source)).parse();\n}\n\nclass Parser {\n  #current = 0;\n\n  constructor(private readonly tokens: Token[]) {}\n\n  parse(): Expr {\n    const expression = this.parseExpression(0);\n    this.consume(\"eof\");\n    return expression;\n  }\n\n  private parseExpression(minPrecedence: number): Expr {\n    let left = this.parsePrefix();\n\n    while (this.peek().type === \"operator\") {\n      const operator = this.peek().lexeme;\n      const precedence = PRECEDENCE.get(operator);\n      if (precedence === undefined || precedence < minPrecedence) {\n        break;\n      }\n\n      this.advance();\n      const right = this.parseExpression(precedence + 1);\n      left = { kind: \"binary\", left, operator, right };\n    }\n\n    return left;\n  }\n\n  private parsePrefix(): Expr {\n    if (this.match(\"operator\", \"!\")) {\n      return { kind: \"unary\", operator: \"!\", right: this.parsePrefix() };\n    }\n\n    if (this.match(\"operator\", \"-\")) {\n      return { kind: \"unary\", operator: \"-\", right: this.parsePrefix() };\n    }\n\n    return this.parsePostfix(this.parsePrimary());\n  }\n\n  private parsePrimary(): Expr {\n    const token = this.advance();\n\n    if (token.type === \"number\" || token.type === \"string\") {\n      return { kind: \"literal\", value: token.value };\n    }\n\n    if (token.type === \"regex\") {\n      const value = token.value as { pattern: string; flags: string };\n      return { kind: \"regex\", pattern: value.pattern, flags: value.flags };\n    }\n\n    if (token.type === \"identifier\") {\n      if (token.lexeme === \"true\") {\n        return { kind: \"literal\", value: true };\n      }\n      if (token.lexeme === \"false\") {\n        return { kind: \"literal\", value: false };\n      }\n      if (token.lexeme === \"null\") {\n        return { kind: \"literal\", value: null };\n      }\n      return { kind: \"identifier\", name: token.lexeme };\n    }\n\n    // Array literal: [expr, expr, ...]\n    if (token.type === \"punct\" && token.lexeme === \"[\") {\n      const elements: Expr[] = [];\n      if (!this.check(\"punct\", \"]\")) {\n        do {\n          elements.push(this.parseExpression(0));\n        } while (this.match(\"punct\", \",\"));\n      }\n      this.consume(\"punct\", \"]\");\n      return { kind: \"array\", elements };\n    }\n\n    if (token.type === \"punct\" && token.lexeme === \"(\") {\n      const expression = this.parseExpression(0);\n      this.consume(\"punct\", \")\");\n      return expression;\n    }\n\n    throw new Error(`Expected expression near \"${token.lexeme}\"`);\n  }\n\n  private parsePostfix(expression: Expr): Expr {\n    let current = expression;\n\n    while (true) {\n      if (this.match(\"punct\", \".\")) {\n        const property = this.consume(\"identifier\").lexeme;\n        current = { kind: \"member\", object: current, property };\n        continue;\n      }\n\n      if (this.match(\"punct\", \"[\")) {\n        const index = this.parseExpression(0);\n        this.consume(\"punct\", \"]\");\n        current = { kind: \"index\", object: current, index };\n        continue;\n      }\n\n      if (this.match(\"punct\", \"(\")) {\n        const args: Expr[] = [];\n        if (!this.check(\"punct\", \")\")) {\n          do {\n            args.push(this.parseExpression(0));\n          } while (this.match(\"punct\", \",\"));\n        }\n        this.consume(\"punct\", \")\");\n        current = { kind: \"call\", callee: current, args };\n        continue;\n      }\n\n      return current;\n    }\n  }\n\n  private match(type: Token[\"type\"], lexeme?: string): boolean {\n    if (!this.check(type, lexeme)) {\n      return false;\n    }\n    this.advance();\n    return true;\n  }\n\n  private consume(type: Token[\"type\"], lexeme?: string): Token {\n    if (!this.check(type, lexeme)) {\n      throw new Error(\n        `Expected ${lexeme ?? type}, got \"${this.peek().lexeme}\"`,\n      );\n    }\n\n    return this.advance();\n  }\n\n  private check(type: Token[\"type\"], lexeme?: string): boolean {\n    const token = this.peek();\n    return (\n      token.type === type && (lexeme === undefined || token.lexeme === lexeme)\n    );\n  }\n\n  private advance(): Token {\n    const token = this.peek();\n    this.#current += 1;\n    return token;\n  }\n\n  private peek(): Token {\n    return this.tokens[this.#current] ?? { type: \"eof\", lexeme: \"\" };\n  }\n}\n","import YAML from \"yaml\";\n\nexport type BasePropertyConfig = {\n  displayName?: string;\n};\n\nexport type BaseSort = {\n  property: string;\n  direction?: \"ASC\" | \"DESC\";\n};\n\nexport type BaseGroupBy = {\n  property: string;\n  direction?: \"ASC\" | \"DESC\";\n};\n\nexport type BaseView = {\n  type: string;\n  name: string;\n  filters?: unknown;\n  order?: string[];\n  sort?: BaseSort[];\n  limit?: number;\n  groupBy?: BaseGroupBy;\n  summaries?: Record<string, unknown>;\n  raw: Record<string, unknown>;\n};\n\nexport type BaseDefinition = {\n  path: string;\n  source: Record<string, unknown>;\n  properties: Record<string, BasePropertyConfig>;\n  formulas: Record<string, string>;\n  filters?: unknown;\n  summaries?: Record<string, string>;\n  views: BaseView[];\n};\n\nexport function parseBase(path: string, source: string): BaseDefinition {\n  const parsed = YAML.parse(source) as unknown;\n  if (!isRecord(parsed)) {\n    throw new Error(\"Base file must contain a YAML object\");\n  }\n\n  return {\n    path,\n    source: parsed,\n    properties: parseProperties(parsed.properties),\n    formulas: parseFormulas(parsed.formulas),\n    filters: parsed.filters,\n    summaries: parseSummaries(parsed.summaries),\n    views: parseViews(parsed.views),\n  };\n}\n\nexport function validateBase(base: BaseDefinition): string[] {\n  const errors: string[] = [];\n\n  if (!Array.isArray(base.source.views)) {\n    errors.push(\"views must be a list\");\n  }\n\n  for (const [index, view] of base.views.entries()) {\n    if (!view.name) {\n      errors.push(`views[${index}].name is required`);\n    }\n    if (!view.type) {\n      errors.push(`views[${index}].type is required`);\n    }\n  }\n\n  return errors;\n}\n\nfunction parseProperties(value: unknown): Record<string, BasePropertyConfig> {\n  if (!isRecord(value)) {\n    return {};\n  }\n\n  const properties: Record<string, BasePropertyConfig> = {};\n  for (const [name, config] of Object.entries(value)) {\n    properties[name] = isRecord(config)\n      ? { displayName: stringValue(config.displayName) }\n      : {};\n  }\n\n  return properties;\n}\n\nfunction parseFormulas(value: unknown): Record<string, string> {\n  if (!isRecord(value)) {\n    return {};\n  }\n\n  const formulas: Record<string, string> = {};\n  for (const [name, formula] of Object.entries(value)) {\n    formulas[name] = String(formula);\n  }\n\n  return formulas;\n}\n\nfunction parseSummaries(value: unknown): Record<string, string> | undefined {\n  if (!isRecord(value)) {\n    return undefined;\n  }\n\n  const summaries: Record<string, string> = {};\n  for (const [name, formula] of Object.entries(value)) {\n    summaries[name] = String(formula);\n  }\n\n  return summaries;\n}\n\nfunction parseViews(value: unknown): BaseView[] {\n  if (!Array.isArray(value)) {\n    return [];\n  }\n\n  return value.filter(isRecord).map((view) => ({\n    type: stringValue(view.type) ?? \"table\",\n    name: stringValue(view.name) ?? \"\",\n    filters: view.filters,\n    order: Array.isArray(view.order) ? view.order.map(String) : undefined,\n    sort: parseSort(view.sort),\n    limit: typeof view.limit === \"number\" ? view.limit : undefined,\n    groupBy: parseGroupBy(view.groupBy),\n    summaries: isRecord(view.summaries) ? view.summaries : undefined,\n    raw: view,\n  }));\n}\n\nfunction parseGroupBy(value: unknown): BaseGroupBy | undefined {\n  if (!isRecord(value)) {\n    return undefined;\n  }\n\n  const property = stringValue(value.property);\n  if (!property) {\n    return undefined;\n  }\n\n  return {\n    property,\n    direction: value.direction === \"DESC\" ? \"DESC\" : \"ASC\",\n  };\n}\n\nfunction parseSort(value: unknown): BaseSort[] | undefined {\n  if (!Array.isArray(value)) {\n    return undefined;\n  }\n\n  const sort = value.filter(isRecord).flatMap((item) => {\n    const property = stringValue(item.property);\n    if (!property) {\n      return [];\n    }\n\n    return [\n      {\n        property,\n        direction: item.direction === \"DESC\" ? \"DESC\" : \"ASC\",\n      } satisfies BaseSort,\n    ];\n  });\n\n  return sort.length > 0 ? sort : undefined;\n}\n\nfunction stringValue(value: unknown): string | undefined {\n  return typeof value === \"string\" ? value : undefined;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@aliou/obsdx-base-ast",
+  "version": "0.0.1",
+  "description": "Obsidian Base syntax parsing for obsdx",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist/index.d.mts",
+    "dist/index.mjs",
+    "dist/index.mjs.map"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aliou/obsdx",
+    "directory": "packages/base-ast"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=25.7.0"
+  },
+  "dependencies": {
+    "yaml": "^2.7.0"
+  }
+}