@wdprlib/parser 3.2.0 → 4.0.0

package/src/parser/rules/block/module/listpages/extraction/variables.ts

@@ -0,0 +1,58 @@
+import type { ListPagesVariable } from "../types";
+
+const KNOWN_VARIABLES: ReadonlySet<ListPagesVariable> = new Set([
+  "created_at",
+  "created_by",
+  "created_by_unix",
+  "created_by_id",
+  "created_by_linked",
+  "updated_at",
+  "updated_by",
+  "updated_by_unix",
+  "updated_by_id",
+  "updated_by_linked",
+  "commented_at",
+  "commented_by",
+  "commented_by_unix",
+  "commented_by_id",
+  "commented_by_linked",
+  "name",
+  "category",
+  "fullname",
+  "title",
+  "title_linked",
+  "link",
+  "parent_name",
+  "parent_category",
+  "parent_fullname",
+  "parent_title",
+  "parent_title_linked",
+  "content",
+  "preview",
+  "summary",
+  "first_paragraph",
+  "tags",
+  "_tags",
+  "children",
+  "comments",
+  "size",
+  "rating",
+  "rating_votes",
+  "rating_percent",
+  "revisions",
+  "index",
+  "total",
+  "limit",
+  "total_or_limit",
+  "site_title",
+  "site_name",
+  "site_domain",
+]);
+
+export function normalizeVariableName(name: string): ListPagesVariable | null {
+  if (KNOWN_VARIABLES.has(name as ListPagesVariable)) {
+    return name as ListPagesVariable;
+  }
+
+  return null;
+}

package/src/parser/rules/block/module/listpages/normalization/date-selector.ts

@@ -0,0 +1,53 @@
+import type { DateComparisonOp, NormalizedDateSelector } from "../types";
+
+/**
+ * Date comparison operators, ordered longest-first.
+ */
+const DATE_COMPARISON_OPS: DateComparisonOp[] = ["<=", ">=", "<>", "<", ">", "="];
+
+/**
+ * Pattern for relative date expressions like "last 7 days".
+ */
+const RELATIVE_DATE_PATTERN = /^last\s+(?:(\d+)\s+)?(day|week|month)s?$/i;
+
+/**
+ * Parse date selector string into structured format.
+ */
+export function parseDateSelector(value: string): NormalizedDateSelector | undefined {
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+
+  const relativeMatch = trimmed.match(RELATIVE_DATE_PATTERN);
+  if (relativeMatch && relativeMatch[2]) {
+    const count = relativeMatch[1] ? parseInt(relativeMatch[1], 10) : 1;
+    if (count < 1) return undefined;
+    const unit = relativeMatch[2].toLowerCase() as "day" | "week" | "month";
+    return { type: "relative", unit, count };
+  }
+
+  for (const op of DATE_COMPARISON_OPS) {
+    if (trimmed.startsWith(op)) {
+      const date = trimmed.slice(op.length).trim();
+      if (date) {
+        return { type: "comparison", op, date };
+      }
+    }
+  }
+
+  if (/^\d{4}$/.test(trimmed)) {
+    return { type: "year", year: parseInt(trimmed, 10) };
+  }
+
+  const monthMatch = trimmed.match(/^(\d{4})\.(\d{1,2})$/);
+  if (monthMatch && monthMatch[1] && monthMatch[2]) {
+    const month = parseInt(monthMatch[2], 10);
+    if (month < 1 || month > 12) return undefined;
+    return {
+      type: "month",
+      year: parseInt(monthMatch[1], 10),
+      month,
+    };
+  }
+
+  return undefined;
+}

package/src/parser/rules/block/module/listpages/normalization/numeric-selector.ts

@@ -0,0 +1,32 @@
+import type { NormalizedNumericSelector, NumericComparisonOp } from "../types";
+
+/**
+ * Numeric comparison operators, ordered longest-first.
+ */
+const NUMERIC_COMPARISON_OPS: NumericComparisonOp[] = ["<=", ">=", "<", ">", "="];
+
+/**
+ * Parse numeric selector string into structured format.
+ */
+export function parseNumericSelector(value: string): NormalizedNumericSelector | undefined {
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+
+  for (const op of NUMERIC_COMPARISON_OPS) {
+    if (trimmed.startsWith(op)) {
+      const numStr = trimmed.slice(op.length).trim();
+      const num = parseFloat(numStr);
+      if (Number.isFinite(num) && /^-?\d+(\.\d+)?$/.test(numStr)) {
+        return { op, value: num };
+      }
+      return undefined;
+    }
+  }
+
+  const num = parseFloat(trimmed);
+  if (Number.isFinite(num) && /^-?\d+(\.\d+)?$/.test(trimmed)) {
+    return { op: "=", value: num };
+  }
+
+  return undefined;
+}

package/src/parser/rules/block/module/listpages/normalization/order-parent.ts

@@ -0,0 +1,82 @@
+import type { NormalizedOrder, NormalizedParent, OrderDirection, OrderField } from "../types";
+
+/**
+ * Mapping from Wikidot's order field names to normalized OrderField values.
+ */
+const ORDER_FIELD_MAP: Record<string, OrderField> = {
+  datecreated: "created_at",
+  dateedited: "updated_at",
+  title: "title",
+  fullname: "fullname",
+  rating: "rating",
+  votes: "votes",
+  revisions: "revisions",
+  comments: "comments",
+  pagelength: "size",
+  size: "size",
+  random: "random",
+  created_at: "created_at",
+  updated_at: "updated_at",
+};
+
+/**
+ * Parse order string into structured format.
+ */
+export function parseOrder(value: string): NormalizedOrder {
+  const defaultOrder: NormalizedOrder = { field: "created_at", direction: "desc" };
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) return defaultOrder;
+
+  const spaceParts = trimmed.split(/\s+/);
+  if (spaceParts.length >= 2 && spaceParts[0] && spaceParts[1]) {
+    const field = ORDER_FIELD_MAP[spaceParts[0]];
+    const direction = spaceParts[1] === "asc" ? "asc" : "desc";
+    if (field) {
+      return { field, direction };
+    }
+  }
+
+  let direction: OrderDirection = "desc";
+  let fieldPart = trimmed;
+
+  if (trimmed.endsWith("desc")) {
+    direction = "desc";
+    fieldPart = trimmed.slice(0, -4);
+  } else if (trimmed.endsWith("asc")) {
+    direction = "asc";
+    fieldPart = trimmed.slice(0, -3);
+  }
+
+  const field = ORDER_FIELD_MAP[fieldPart];
+  if (field) {
+    return { field, direction };
+  }
+
+  const singleField = ORDER_FIELD_MAP[trimmed];
+  if (singleField) {
+    return { field: singleField, direction: "desc" };
+  }
+
+  return defaultOrder;
+}
+
+/**
+ * Parse parent string into structured format.
+ */
+export function parseParent(value: string): NormalizedParent | undefined {
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+
+  switch (trimmed) {
+    case "-":
+      return { type: "none" };
+    case "=":
+      return { type: "same" };
+    case "-=":
+      return { type: "different" };
+    case ".":
+      return { type: "children" };
+    default:
+      return { type: "page", name: trimmed };
+  }
+}

package/src/parser/rules/block/module/listpages/normalization/selectors.ts

@@ -0,0 +1,2 @@
+export { parseDateSelector } from "./date-selector";
+export { parseNumericSelector } from "./numeric-selector";

package/src/parser/rules/block/module/listpages/normalization/tags-category.ts

@@ -0,0 +1,86 @@
+import type { NormalizedCategory, NormalizedTags } from "../types";
+
+/**
+ * Pattern for splitting multi-value attribute strings.
+ * Wikidot allows commas, semicolons, and whitespace as separators between values.
+ */
+const TOKEN_SEPARATOR = /[,;\s]+/;
+
+/**
+ * Parse tags string into structured format.
+ */
+export function parseTags(value: string): NormalizedTags {
+  const result: NormalizedTags = {
+    all: [],
+    any: [],
+    none: [],
+    special: null,
+  };
+
+  const trimmed = value.trim();
+  if (!trimmed) return result;
+
+  if (trimmed === "-") {
+    result.special = "none";
+    return result;
+  }
+  if (trimmed === "==") {
+    result.special = "same-all";
+    return result;
+  }
+
+  const tokens = trimmed.split(TOKEN_SEPARATOR).filter(Boolean);
+
+  for (const token of tokens) {
+    if (token === "=") {
+      result.special = "same-visible";
+    } else if (token.startsWith("+")) {
+      const tag = token.slice(1);
+      if (tag) result.all.push(tag);
+    } else if (token.startsWith("-")) {
+      const tag = token.slice(1);
+      if (tag) result.none.push(tag);
+    } else {
+      result.any.push(token);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Parse category string into structured format.
+ */
+export function parseCategory(value: string): NormalizedCategory {
+  const result: NormalizedCategory = {
+    include: [],
+    exclude: [],
+    all: false,
+    current: false,
+  };
+
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) return result;
+
+  if (trimmed === "*") {
+    result.all = true;
+    return result;
+  }
+
+  const tokens = trimmed.split(TOKEN_SEPARATOR).filter(Boolean);
+
+  for (const token of tokens) {
+    if (token === "*") {
+      result.all = true;
+    } else if (token === ".") {
+      result.current = true;
+    } else if (token.startsWith("-")) {
+      const cat = token.slice(1);
+      if (cat) result.exclude.push(cat);
+    } else {
+      result.include.push(token);
+    }
+  }
+
+  return result;
+}

package/src/parser/rules/block/module/listpages/normalize.ts

@@ -14,330 +14,14 @@
  * @module
  */
 
-import type {
-  ListPagesQuery,
-  NormalizedListPagesQuery,
-  NormalizedTags,
-  NormalizedCategory,
-  NormalizedOrder,
-  NormalizedParent,
-  NormalizedDateSelector,
-  NormalizedNumericSelector,
-  OrderField,
-  OrderDirection,
-  DateComparisonOp,
-  NumericComparisonOp,
-} from "./types";
-
-/**
- * Pattern for splitting multi-value attribute strings.
- * Wikidot allows commas, semicolons, and whitespace as separators between values.
- */
-const TOKEN_SEPARATOR = /[,;\s]+/;
-
-/**
- * Parse tags string into structured format
- *
- * Syntax:
- * - `+tag`: AND condition (must have this tag)
- * - `-tag`: NOT condition (must not have this tag)
- * - `tag`: OR condition (any of these tags)
- * - `=`: same visible tags as current page
- * - `==`: exact same tags as current page
- * - `-`: pages with no tags
- */
-export function parseTags(value: string): NormalizedTags {
-  const result: NormalizedTags = {
-    all: [],
-    any: [],
-    none: [],
-    special: null,
-  };
-
-  const trimmed = value.trim();
-  if (!trimmed) return result;
-
-  // Check for special selectors
-  if (trimmed === "-") {
-    result.special = "none";
-    return result;
-  }
-  if (trimmed === "==") {
-    result.special = "same-all";
-    return result;
-  }
-
-  const tokens = trimmed.split(TOKEN_SEPARATOR).filter(Boolean);
-
-  for (const token of tokens) {
-    if (token === "=") {
-      result.special = "same-visible";
-    } else if (token.startsWith("+")) {
-      const tag = token.slice(1);
-      if (tag) result.all.push(tag);
-    } else if (token.startsWith("-")) {
-      const tag = token.slice(1);
-      if (tag) result.none.push(tag);
-    } else {
-      result.any.push(token);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Parse category string into structured format
- *
- * Syntax:
- * - `*`: all categories
- * - `.`: current category
- * - `-category`: exclude category
- * - `category`: include category
- * - Multiple categories separated by comma, semicolon, or whitespace
- */
-export function parseCategory(value: string): NormalizedCategory {
-  const result: NormalizedCategory = {
-    include: [],
-    exclude: [],
-    all: false,
-    current: false,
-  };
-
-  const trimmed = value.trim().toLowerCase();
-  if (!trimmed) return result;
-
-  if (trimmed === "*") {
-    result.all = true;
-    return result;
-  }
-
-  const tokens = trimmed.split(TOKEN_SEPARATOR).filter(Boolean);
-
-  for (const token of tokens) {
-    if (token === "*") {
-      result.all = true;
-    } else if (token === ".") {
-      result.current = true;
-    } else if (token.startsWith("-")) {
-      const cat = token.slice(1);
-      if (cat) result.exclude.push(cat);
-    } else {
-      result.include.push(token);
-    }
-  }
-
-  return result;
-}
-
-/**
- * Mapping from Wikidot's order field names (both camelCase PHP-style and
- * snake_case documentation-style) to normalized `OrderField` values.
- */
-const ORDER_FIELD_MAP: Record<string, OrderField> = {
-  // camelCase format (Wikidot PHP style)
-  datecreated: "created_at",
-  dateedited: "updated_at",
-  title: "title",
-  fullname: "fullname",
-  rating: "rating",
-  votes: "votes",
-  revisions: "revisions",
-  comments: "comments",
-  pagelength: "size",
-  size: "size",
-  random: "random",
-  // snake_case format (documentation style)
-  created_at: "created_at",
-  updated_at: "updated_at",
-};
-
-/**
- * Parse order string into structured format
- *
- * Supports both formats:
- * - camelCase: `dateCreatedDesc`, `titleAsc`, `ratingDesc`
- * - Space-separated: `created_at desc`, `title asc`
- *
- * Default: { field: "created_at", direction: "desc" }
- */
-export function parseOrder(value: string): NormalizedOrder {
-  const defaultOrder: NormalizedOrder = { field: "created_at", direction: "desc" };
-  const trimmed = value.trim().toLowerCase();
-  if (!trimmed) return defaultOrder;
-
-  // Try space-separated format: "created_at desc"
-  const spaceParts = trimmed.split(/\s+/);
-  if (spaceParts.length >= 2 && spaceParts[0] && spaceParts[1]) {
-    const field = ORDER_FIELD_MAP[spaceParts[0]];
-    const direction = spaceParts[1] === "asc" ? "asc" : "desc";
-    if (field) {
-      return { field, direction };
-    }
-  }
-
-  // Try camelCase format: "dateCreatedDesc"
-  let direction: OrderDirection = "desc";
-  let fieldPart = trimmed;
-
-  if (trimmed.endsWith("desc")) {
-    direction = "desc";
-    fieldPart = trimmed.slice(0, -4);
-  } else if (trimmed.endsWith("asc")) {
-    direction = "asc";
-    fieldPart = trimmed.slice(0, -3);
-  }
-
-  const field = ORDER_FIELD_MAP[fieldPart];
-  if (field) {
-    return { field, direction };
-  }
-
-  // Try single word (field only, use default direction)
-  const singleField = ORDER_FIELD_MAP[trimmed];
-  if (singleField) {
-    return { field: singleField, direction: "desc" };
-  }
-
-  return defaultOrder;
-}
-
-/**
- * Parse parent string into structured format
- *
- * Syntax:
- * - `-`: orphan pages (no parent)
- * - `=`: sibling pages (same parent as current)
- * - `-=`: pages with different parent
- * - `.`: children of current page
- * - `page-name`: children of specific page
- *
- * Returns undefined for empty/whitespace-only input.
- */
-export function parseParent(value: string): NormalizedParent | undefined {
-  const trimmed = value.trim();
-  if (!trimmed) return undefined;
-
-  switch (trimmed) {
-    case "-":
-      return { type: "none" };
-    case "=":
-      return { type: "same" };
-    case "-=":
-      return { type: "different" };
-    case ".":
-      return { type: "children" };
-    default:
-      return { type: "page", name: trimmed };
-  }
-}
-
-/**
- * Date comparison operators, ordered longest-first so longer operators
- * (like `<=`) are matched before shorter ones (like `<`).
- */
-const DATE_COMPARISON_OPS: DateComparisonOp[] = ["<=", ">=", "<>", "<", ">", "="];
-
-/**
- * Pattern for relative date expressions like "last 7 days", "last 2 weeks", "last month".
- * The count is optional and defaults to 1 (e.g., "last month" = "last 1 month").
- */
-const RELATIVE_DATE_PATTERN = /^last\s+(?:(\d+)\s+)?(day|week|month)s?$/i;
-
-/**
- * Parse date selector string into structured format
- *
- * Syntax:
- * - `yyyy`: year only
- * - `yyyy.mm`: year and month
- * - `>=yyyy.mm.dd`: comparison with date
- * - `last 7 days`: relative date
- */
-export function parseDateSelector(value: string): NormalizedDateSelector | undefined {
-  const trimmed = value.trim();
-  if (!trimmed) return undefined;
-
-  // Check relative date format: "last 7 days"
-  const relativeMatch = trimmed.match(RELATIVE_DATE_PATTERN);
-  if (relativeMatch && relativeMatch[2]) {
-    const count = relativeMatch[1] ? parseInt(relativeMatch[1], 10) : 1;
-    // Validate count is at least 1
-    if (count < 1) return undefined;
-    const unit = relativeMatch[2].toLowerCase() as "day" | "week" | "month";
-    return { type: "relative", unit, count };
-  }
-
-  // Check comparison operators
-  for (const op of DATE_COMPARISON_OPS) {
-    if (trimmed.startsWith(op)) {
-      const date = trimmed.slice(op.length).trim();
-      if (date) {
-        return { type: "comparison", op, date };
-      }
-    }
-  }
-
-  // Check year format: "2024"
-  if (/^\d{4}$/.test(trimmed)) {
-    return { type: "year", year: parseInt(trimmed, 10) };
-  }
-
-  // Check year.month format: "2024.03"
-  const monthMatch = trimmed.match(/^(\d{4})\.(\d{1,2})$/);
-  if (monthMatch && monthMatch[1] && monthMatch[2]) {
-    const month = parseInt(monthMatch[2], 10);
-    // Validate month is 1-12
-    if (month < 1 || month > 12) return undefined;
-    return {
-      type: "month",
-      year: parseInt(monthMatch[1], 10),
-      month,
-    };
-  }
-
-  return undefined;
-}
-
-/**
- * Numeric comparison operators, ordered longest-first for correct prefix matching.
- */
-const NUMERIC_COMPARISON_OPS: NumericComparisonOp[] = ["<=", ">=", "<", ">", "="];
-
-/**
- * Parse numeric selector string into structured format
- *
- * Syntax:
- * - `5`: equals 5
- * - `>=10`: greater than or equal to 10
- * - `<0`: less than 0
- *
- * Returns undefined for non-numeric or infinite values.
- */
-export function parseNumericSelector(value: string): NormalizedNumericSelector | undefined {
-  const trimmed = value.trim();
-  if (!trimmed) return undefined;
-
-  // Check comparison operators
-  for (const op of NUMERIC_COMPARISON_OPS) {
-    if (trimmed.startsWith(op)) {
-      const numStr = trimmed.slice(op.length).trim();
-      const num = parseFloat(numStr);
-      // Strict validation: must be finite number and entire string must be numeric
-      if (Number.isFinite(num) && /^-?\d+(\.\d+)?$/.test(numStr)) {
-        return { op, value: num };
-      }
-      return undefined;
-    }
-  }
-
-  // Plain number (equals) - strict validation
-  const num = parseFloat(trimmed);
-  if (Number.isFinite(num) && /^-?\d+(\.\d+)?$/.test(trimmed)) {
-    return { op: "=", value: num };
-  }
-
-  return undefined;
-}
+import type { ListPagesQuery, NormalizedListPagesQuery } from "./types";
+import { parseCategory, parseTags } from "./normalization/tags-category";
+import { parseOrder, parseParent } from "./normalization/order-parent";
+import { parseDateSelector, parseNumericSelector } from "./normalization/selectors";
+
+export { parseCategory, parseTags } from "./normalization/tags-category";
+export { parseOrder, parseParent } from "./normalization/order-parent";
+export { parseDateSelector, parseNumericSelector } from "./normalization/selectors";
 
 /**
  * Normalize a ListPagesQuery into structured types

package/src/parser/rules/block/module/listpages/resolution/items.ts

@@ -0,0 +1,43 @@
+import type { Element } from "@wdprlib/ast";
+import type { CompiledTemplate, ListPagesExternalData, VariableContext } from "../types";
+import type { ParseFunction } from "../../types";
+import type { ListPagesModuleData } from "../resolve";
+
+export function renderListPagesItems(
+  module: ListPagesModuleData,
+  data: ListPagesExternalData,
+  compiledTemplate: CompiledTemplate,
+  parse: ParseFunction,
+): Element[] {
+  const items: Element[] = [];
+
+  for (let i = 0; i < data.pages.length; i++) {
+    const page = data.pages[i];
+    if (!page) continue;
+
+    const ctx: VariableContext = {
+      page,
+      index: i + 1,
+      total: data.totalCount,
+      limit: module.limit,
+      site: data.site,
+    };
+
+    const itemAst = parse(compiledTemplate(ctx));
+
+    if (module.separate) {
+      items.push({
+        element: "container",
+        data: {
+          type: "div",
+          attributes: { class: "list-pages-item" },
+          elements: itemAst.elements,
+        },
+      });
+    } else {
+      items.push(...itemAst.elements);
+    }
+  }
+
+  return items;
+}