@art-md/constructs 0.0.4 → 0.0.6

package/dist/index.mjs

@@ -0,0 +1,627 @@
+// ../primitives/dist/index.mjs
+function createArtDocument(data) {
+  return {
+    construct: "Document",
+    children: data?.children ?? []
+  };
+}
+function nodePosition(node) {
+  if (!node.position) {
+    throw new Error(`Expected source position for ${node.type}`);
+  }
+  const raw = node.position;
+  if (!raw?.start || !raw.end) {
+    throw new Error(`Expected source position for ${node.type}`);
+  }
+  return {
+    start: {
+      line: raw.start.line,
+      column: raw.start.column,
+      offset: raw.start.offset ?? 0
+    },
+    end: {
+      line: raw.end.line,
+      column: raw.end.column,
+      offset: raw.end.offset ?? 0
+    }
+  };
+}
+function sectionDepth(section) {
+  return section.depth ?? 1;
+}
+
+// src/factories/constructs/Document/factory/createDocument.ts
+function createDocument(data) {
+  const docData = {
+    ...data,
+    children: data.children || []
+  };
+  return createArtDocument(docData);
+}
+
+// src/factories/constructs/FieldBlock/factory/createFieldBlock.ts
+function createFieldBlock(data) {
+  const field = {
+    construct: "FieldBlock",
+    name: data.name,
+    children: data.children ?? []
+  };
+  if (data.tags?.length) {
+    field.tags = data.tags;
+  }
+  return field;
+}
+
+// src/factories/constructs/FieldInline/factory/createFieldInline.ts
+function createFieldInline(data) {
+  const field = {
+    construct: "FieldInline",
+    name: data.name,
+    children: data.children ?? []
+  };
+  if (data.tags?.length) {
+    field.tags = data.tags;
+  }
+  return field;
+}
+
+// src/factories/constructs/NaturalBlock/factory/createNaturalBlock.ts
+function createNaturalBlock(data) {
+  const block = {
+    ...data.attributes,
+    construct: "NaturalBlock",
+    value: data.value,
+    children: data.children
+  };
+  if (data.type) {
+    block.type = data.type;
+  }
+  if (data.lang !== void 0) {
+    block.lang = data.lang;
+  }
+  if (data.meta !== void 0) {
+    block.meta = data.meta;
+  }
+  if (data.tags?.length) {
+    block.tags = data.tags;
+  }
+  return block;
+}
+
+// src/factories/constructs/NaturalExpression/factory/createNaturalExpression.ts
+function createNaturalExpression(data) {
+  return {
+    construct: "NaturalExpression",
+    type: data.type,
+    value: data.value,
+    attributes: data.attributes,
+    children: data.children ?? []
+  };
+}
+
+// src/factories/constructs/SectionBlock/factory/createSectionBlock.ts
+function createSectionBlock(data) {
+  const section = {
+    construct: "SectionBlock",
+    name: data.name,
+    children: data.children ?? []
+  };
+  if (data.depth !== void 0) section.depth = data.depth;
+  if (data.tags?.length) section.tags = data.tags;
+  return section;
+}
+
+// src/factories/constructs/Tag/factory/createTag.ts
+function createTag(tagData) {
+  return { construct: "Tag", name: tagData.name };
+}
+
+// src/factories/public.ts
+var FACTORIES = [
+  {
+    name: "Document",
+    factory: createDocument
+  },
+  {
+    name: "FieldBlock",
+    factory: createFieldBlock
+  },
+  {
+    name: "FieldInline",
+    factory: createFieldInline
+  },
+  {
+    name: "NaturalBlock",
+    factory: createNaturalBlock
+  },
+  {
+    name: "NaturalExpression",
+    factory: createNaturalExpression
+  },
+  {
+    name: "SectionBlock",
+    factory: createSectionBlock
+  },
+  {
+    name: "Tag",
+    factory: createTag
+  }
+];
+
+// src/parser/constructs/FieldBlock/private/helpers/onBeforeConstruct.ts
+var FIELD_BLOCK_BOUNDARIES = /* @__PURE__ */ new Set(["FieldBlock", "FieldInline", "SectionBlock"]);
+function onBeforeConstruct(construct, context) {
+  if (!FIELD_BLOCK_BOUNDARIES.has(construct.construct)) {
+    return context;
+  }
+  const parent = context.parent();
+  if (!parent) {
+    return context;
+  }
+  return parent;
+}
+
+// src/parser/constructs/FieldBlock/private/integrator/createFieldBlockIntegrator.ts
+function createFieldBlockIntegrator() {
+  return {
+    integrate(context, _node, construct) {
+      const field = construct;
+      context.captureChildConstruct(field);
+      return context.childContext(field, onBeforeConstruct);
+    }
+  };
+}
+
+// src/parser/fields/constants.ts
+var FIELD_TEXT_PATTERN = /^[A-Za-z][A-Za-z ]*:(?:\s|$)/;
+
+// src/parser/mdast/rawSlice.ts
+function rawSlice(node, context) {
+  if (!node.position?.start || !node.position?.end) {
+    return "";
+  }
+  return context.source.markdown.slice(node.position.start.offset, node.position.end.offset);
+}
+
+// src/parser/fields/stripStrong.ts
+function stripStrong(node, context) {
+  const raw = rawSlice(node, context);
+  return raw.length >= 4 && (raw.startsWith("**") && raw.endsWith("**") || raw.startsWith("__") && raw.endsWith("__")) ? raw.slice(2, -2) : raw;
+}
+
+// src/parser/fields/isFieldStrong.ts
+function isFieldStrong(node, context) {
+  return node.type === "strong" && FIELD_TEXT_PATTERN.test(stripStrong(node, context));
+}
+
+// src/parser/tags/extractTags.ts
+var TRAILING_TAGS = /^(.*?)((?:\(#[\w-]+\)\s*)+)$/;
+var TAG = /\(#([\w-]+)\)/g;
+function extractTags(text) {
+  const trimmed = text.trimEnd();
+  const match = trimmed.match(TRAILING_TAGS);
+  if (!match || !match[1] || !match[2]) {
+    return {
+      tags: [],
+      stripped: text
+    };
+  }
+  const tags = [...match[2].matchAll(TAG)].map(
+    (matchResult) => createTag({ name: matchResult[1] ?? "" })
+  );
+  return {
+    tags,
+    stripped: match[1].trimEnd()
+  };
+}
+
+// src/parser/constructs/FieldBlock/private/helpers/createFieldBlockFromNode.ts
+function createFieldBlockFromNode(paragraph, context) {
+  const strong = paragraph.children[0];
+  const paragraphRaw = rawSlice(paragraph, context);
+  const strongRaw = rawSlice(strong, context);
+  const afterStrong = paragraphRaw.slice(strongRaw.length);
+  const { tags, stripped } = extractTags(afterStrong);
+  if (stripped.trim().length > 0) {
+    return null;
+  }
+  const inner = stripStrong(strong, context);
+  const colonIndex = inner.indexOf(":");
+  const field = createFieldBlock({
+    name: inner.slice(0, colonIndex).trim(),
+    tags
+  });
+  field.position = nodePosition(paragraph);
+  return field;
+}
+
+// src/parser/constructs/FieldBlock/private/processor/createFieldBlockProcessor.ts
+function createFieldBlockProcessor() {
+  return {
+    captureNode(context, node) {
+      if (node.type !== "paragraph") {
+        return null;
+      }
+      const paragraph = node;
+      const first = paragraph.children[0];
+      if (first === void 0 || !isFieldStrong(first, context)) {
+        return null;
+      }
+      return createFieldBlockFromNode(paragraph, context);
+    }
+  };
+}
+
+// src/parser/constructs/FieldBlock/createFieldBlockParser.ts
+var createFieldBlockParser = () => ({
+  name: "FieldBlock",
+  processor: createFieldBlockProcessor(),
+  integrator: createFieldBlockIntegrator()
+});
+
+// src/parser/naturalExpression/createNaturalExpressionFromNode.ts
+function createNaturalExpressionFromNode(node) {
+  const { position: _, children: mdastChildren, type, value, ...attributes } = node;
+  let children = [];
+  if (Array.isArray(mdastChildren)) {
+    children = mdastChildren.map((child) => createNaturalExpressionFromNode(child));
+  }
+  const expression = {
+    construct: "NaturalExpression",
+    type,
+    attributes,
+    value,
+    position: nodePosition(node),
+    children
+  };
+  return expression;
+}
+
+// src/parser/constructs/FieldInline/private/helpers/trimFieldEdges.ts
+function trimFieldEdges(value) {
+  const trimmed = [...value];
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+  if (first?.type === "text" && typeof first?.value === "string")
+    first.value = first.value.replace(/^\s+/, "");
+  if (last?.type === "text" && typeof last?.value === "string")
+    last.value = last.value.replace(/\s+$/, "");
+  return trimmed.filter(
+    (expression) => expression.type !== "text" || typeof expression.value === "string" && expression.value.length > 0
+  );
+}
+
+// src/parser/constructs/FieldInline/private/helpers/createFieldInlineFromNode.ts
+function createFieldInlineFromNode(paragraph, context) {
+  const strong = paragraph.children[0];
+  const paragraphRaw = rawSlice(paragraph, context);
+  const strongRaw = rawSlice(strong, context);
+  const afterStrong = paragraphRaw.slice(strongRaw.length);
+  const { stripped } = extractTags(afterStrong);
+  if (stripped.trim().length === 0) {
+    return null;
+  }
+  const inner = stripStrong(strong, context);
+  const colonIndex = inner.indexOf(":");
+  const expressions = paragraph.children.slice(1).map((child) => createNaturalExpressionFromNode(child));
+  const children = trimFieldEdges(expressions);
+  const last = children[children.length - 1];
+  let tags = [];
+  if (last?.type === "text" && typeof last.value === "string") {
+    const extracted = extractTags(last.value);
+    if (extracted.tags.length) {
+      tags = extracted.tags;
+      last.value = extracted.stripped;
+    }
+  }
+  const field = createFieldInline({
+    name: inner.slice(0, colonIndex).trim(),
+    children,
+    tags
+  });
+  field.position = nodePosition(paragraph);
+  return field;
+}
+
+// src/parser/constructs/FieldInline/private/processor/createFieldInlineProcessor.ts
+function createFieldInlineProcessor() {
+  return {
+    captureNode(context, node) {
+      if (node.type !== "paragraph") {
+        return null;
+      }
+      const paragraph = node;
+      const first = paragraph.children[0];
+      if (first === void 0 || !isFieldStrong(first, context)) {
+        return null;
+      }
+      return createFieldInlineFromNode(paragraph, context);
+    }
+  };
+}
+
+// src/parser/constructs/FieldInline/createFieldInlineParser.ts
+var createFieldInlineParser = () => ({
+  name: "FieldInline",
+  processor: createFieldInlineProcessor()
+});
+
+// src/parser/constructs/NaturalBlock/private/helpers/createNaturalBlockFromNode.ts
+import { phrasing } from "mdast-util-phrasing";
+function createNaturalBlockFromNode(node, context) {
+  let children = [];
+  if (Array.isArray(node.children)) {
+    const nodeChildren = node.children ?? [];
+    const phrasingContainer = node.type === "paragraph" || node.type === "heading" || node.type === "tableCell";
+    children = nodeChildren.map(
+      (child) => phrasingContainer || phrasing(child) ? createNaturalExpressionFromNode(child) : createNaturalBlockFromNode(child, context)
+    );
+  }
+  let tags = [];
+  if (node.type === "paragraph") {
+    const last = children[children.length - 1];
+    if (last?.type === "text" && typeof last.value === "string") {
+      const { tags: extractedTags, stripped } = extractTags(last.value);
+      if (extractedTags.length) {
+        tags = extractedTags;
+        last.value = stripped;
+      }
+    }
+  }
+  const { type, ...attributes } = node;
+  const block = createNaturalBlock({
+    value: rawSlice(node, context),
+    children,
+    type,
+    attributes,
+    tags
+  });
+  block.position = nodePosition(node);
+  return block;
+}
+
+// src/parser/constructs/NaturalBlock/private/processor/createNaturalBlockProcessor.ts
+function createNaturalBlockProcessor() {
+  return {
+    captureNode(context, node) {
+      return createNaturalBlockFromNode(node, context);
+    }
+  };
+}
+
+// src/parser/constructs/NaturalBlock/createNaturalBlockParser.ts
+var createNaturalBlockParser = () => ({
+  name: "NaturalBlock",
+  processor: createNaturalBlockProcessor()
+});
+
+// src/parser/constructs/SectionBlock/private/helpers/findParentSection.ts
+function findParentSection(context) {
+  let current = context;
+  while (current) {
+    if (current.construct?.construct === "SectionBlock") {
+      return current.construct;
+    }
+    current = current.parent();
+  }
+  return void 0;
+}
+
+// src/parser/constructs/SectionBlock/private/integrator/createSectionBlockIntegrator.ts
+function createSectionBlockIntegrator() {
+  return {
+    integrate(context, node, construct) {
+      const section = construct;
+      let currentContext = context;
+      const heading = node;
+      while (currentContext.construct.construct === "SectionBlock") {
+        const parentSection = findParentSection(currentContext);
+        if (parentSection && sectionDepth(parentSection) >= heading.depth) {
+          const parentContext = currentContext.parent();
+          if (parentContext) {
+            currentContext = parentContext;
+          }
+        } else {
+          break;
+        }
+      }
+      currentContext.captureChildConstruct(section);
+      return currentContext.childContext(section);
+    }
+  };
+}
+
+// src/parser/constructs/SectionBlock/private/helpers/createSectionBlockFromNode.ts
+function createSectionBlockFromNode(node, context) {
+  const text = rawSlice(node, context).replace(/^[ \t]*#+[ \t]*/, "").trim();
+  const { tags, stripped } = extractTags(text);
+  const section = createSectionBlock({
+    name: stripped,
+    depth: node.depth,
+    children: [],
+    tags
+  });
+  section.position = nodePosition(node);
+  return section;
+}
+
+// src/parser/constructs/SectionBlock/private/processor/createSectionBlockProcessor.ts
+function createSectionBlockProcessor() {
+  return {
+    captureNode(context, node) {
+      if (node.type !== "heading") {
+        return null;
+      }
+      return createSectionBlockFromNode(node, context);
+    }
+  };
+}
+
+// src/parser/constructs/SectionBlock/createSectionBlockParser.ts
+var createSectionBlockParser = () => ({
+  name: "SectionBlock",
+  processor: createSectionBlockProcessor(),
+  integrator: createSectionBlockIntegrator()
+});
+
+// src/parser/document/createArtDocumentFromNode.ts
+function createArtDocumentFromNode(root) {
+  const document = createDocument({});
+  document.position = nodePosition(root);
+  return document;
+}
+
+// src/parser/public.ts
+var CONSTRUCT_PARSERS = [
+  createFieldBlockParser,
+  createFieldInlineParser,
+  createSectionBlockParser
+];
+var DEFAULT_CONSTRUCT_PARSER = createNaturalBlockParser;
+
+// src/serializer/constructs/Document/createDocumentToMdast.ts
+function createDocumentToMdast() {
+  return {
+    name: "Document",
+    toMdast(_node, children) {
+      return {
+        type: "root",
+        children
+      };
+    }
+  };
+}
+
+// src/serializer/tags/tagToMdast.ts
+function tagToMdast(tag) {
+  return { type: "text", value: `(#${tag.name})` };
+}
+
+// src/serializer/tags/tagsToMdast.ts
+function tagsToMdast(tags) {
+  const value = tags.map((tag) => tagToMdast(tag).value).join(" ");
+  return { type: "text", value: ` ${value}` };
+}
+
+// src/serializer/constructs/FieldBlock/createFieldBlockToMdast.ts
+function createFieldBlockToMdast() {
+  return {
+    name: "FieldBlock",
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    toMdast(node, _children) {
+      const field = node;
+      const tagNode = field.tags?.length ? tagsToMdast(field.tags) : null;
+      return {
+        type: "paragraph",
+        children: [
+          {
+            type: "strong",
+            children: [{ type: "text", value: `${field.name}:` }]
+          },
+          ...tagNode ? [tagNode] : []
+        ]
+      };
+    }
+  };
+}
+
+// src/serializer/constructs/FieldInline/createFieldInlineToMdast.ts
+function createFieldInlineToMdast() {
+  return {
+    name: "FieldInline",
+    toMdast(node, children) {
+      const field = node;
+      const tagNode = field.tags?.length ? tagsToMdast(field.tags) : null;
+      return {
+        type: "paragraph",
+        children: [
+          {
+            type: "strong",
+            children: [{ type: "text", value: `${field.name}:` }]
+          },
+          { type: "text", value: " " },
+          ...children,
+          ...tagNode ? [tagNode] : []
+        ]
+      };
+    }
+  };
+}
+
+// src/serializer/constructs/NaturalBlock/createNaturalBlockToMdast.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+function createNaturalBlockToMdast() {
+  return {
+    name: "NaturalBlock",
+    toMdast(node, children) {
+      const block = node;
+      const parsed = fromMarkdown(block.value);
+      if (block.type === "paragraph" && children.length > 0) {
+        const paragraph = parsed.children.find((child) => child.type === "paragraph");
+        if (paragraph && "children" in paragraph) {
+          const tagNode = block.tags?.length ? tagsToMdast(block.tags) : null;
+          paragraph.children = [
+            ...children,
+            ...tagNode ? [tagNode] : []
+          ];
+        }
+      }
+      return {
+        type: "root",
+        children: parsed.children
+      };
+    }
+  };
+}
+
+// src/serializer/constructs/NaturalExpression/createNaturalExpressionToMdast.ts
+function createNaturalExpressionToMdast() {
+  return {
+    name: "NaturalExpression",
+    toMdast(node, children) {
+      const expression = node;
+      const attributes = { ...expression.attributes };
+      return { type: expression.type, value: expression.value, children, ...attributes };
+    }
+  };
+}
+
+// src/serializer/constructs/SectionBlock/createSectionBlockToMdast.ts
+import { fromMarkdown as fromMarkdown2 } from "mdast-util-from-markdown";
+function createSectionBlockToMdast() {
+  return {
+    name: "SectionBlock",
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    toMdast(node, _children) {
+      const section = node;
+      const depth = section.depth ?? 1;
+      const parsed = fromMarkdown2(`# ${section.name}`);
+      const heading = parsed.children.find((child) => child.type === "heading");
+      const tagNode = section.tags?.length ? tagsToMdast(section.tags) : null;
+      const children = heading && "children" in heading ? [...heading.children, ...tagNode ? [tagNode] : []] : [{ type: "text", value: section.name }, ...tagNode ? [tagNode] : []];
+      return {
+        type: "heading",
+        depth,
+        children
+      };
+    }
+  };
+}
+
+// src/serializer/public.ts
+var CONSTRUCT_SERIALIZERS = [
+  createDocumentToMdast,
+  createFieldBlockToMdast,
+  createFieldInlineToMdast,
+  createNaturalBlockToMdast,
+  createNaturalExpressionToMdast,
+  createSectionBlockToMdast
+];
+export {
+  CONSTRUCT_PARSERS,
+  CONSTRUCT_SERIALIZERS,
+  DEFAULT_CONSTRUCT_PARSER,
+  FACTORIES,
+  createArtDocumentFromNode
+};
+//# sourceMappingURL=index.mjs.map