@omega.js/web 0.1.0

package/dist/vendor/template-kit/jekyll-compat.js

@@ -0,0 +1,268 @@
+/**
+ * jekyll-compat.js — omega's template helpers under the familiar Jekyll-style
+ * names (slugify, date_to_xmlschema, jsonify, strip_html, markdownify,
+ * relative_url, absolute_url, where_exp, group_by_exp, number_of_words,
+ * date_to_rfc822), as plain JS.
+ *
+ * The names are the authoring surface; the contract is CORRECT BEHAVIOR, not
+ * emulation of Jekyll internals — where Jekyll's own semantics are surprising,
+ * these do the sane thing and the tests pin it.
+ *
+ * where_exp/group_by_exp read the SIMPLE expression subset (`item.path ==
+ * literal`, !=, >, <, >=, <=, contains, and bare paths) — full Liquid
+ * expression support is out of scope; widen it when a site needs more.
+ */
+
+// Constants
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+const DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+
+/**
+ * Jekyll slugify (default mode): downcase, non-alphanumeric runs => '-'.
+ *
+ * An apostrophe is DELETED, not separated on (#597) — legacy UJM dropped it,
+ * so "Beginner's Guides" is `beginners-guides` and every migrating brand's
+ * apostrophe category keeps its live URL. Both spellings, straight and
+ * typographic: the markdown typographer smartens the straight one at build
+ * time, and one term must never answer to two slugs.
+ * @param {string} input
+ * @returns {string}
+ */
+function slugify(input) {
+  return String(input)
+    .toLowerCase()
+    .replace(/['’]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function toDate(input) {
+  if (input === 'now' || input === 'today') return new Date();
+  const parsed = input instanceof Date ? input : new Date(input);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
+function pad(value) {
+  return String(value).padStart(2, '0');
+}
+
+/**
+ * ISO-8601 in UTC, CI-Jekyll parity: "2008-11-07T13:07:54+00:00".
+ * OMEGA convention: content dates are UTC midnights (dated filenames) and CI
+ * builds run UTC — rendering in the builder's local zone would shift days.
+ * @param {Date|string} input
+ * @returns {string|Date} Formatted string; unparseable input passes through untouched
+ */
+function dateToXmlschema(input) {
+  const date = toDate(input);
+  if (!date) return input;
+
+  return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}`
+    + `T${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}`
+    + '+00:00';
+}
+
+/**
+ * RFC-822 in UTC, CI-Jekyll parity: "Fri, 07 Nov 2008 13:07:54 +0000".
+ * @param {Date|string} input
+ * @returns {string|Date} Formatted string; unparseable input passes through untouched
+ */
+function dateToRfc822(input) {
+  const date = toDate(input);
+  if (!date) return input;
+
+  return `${DAYS[date.getUTCDay()]}, ${pad(date.getUTCDate())} ${MONTHS[date.getUTCMonth()]} ${date.getUTCFullYear()}`
+    + ` ${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())} +0000`;
+}
+
+/**
+ * JSON-encode a value (Jekyll's jsonify).
+ * @param {*} input
+ * @returns {string}
+ */
+function jsonify(input) {
+  // Jekyll parity: nil.to_json == "null" (an absent value must still emit valid JS)
+  return JSON.stringify(input === undefined ? null : input);
+}
+
+/**
+ * Strip HTML tags (script/style contents removed entirely).
+ * @param {string} input
+ * @returns {string}
+ */
+function stripHtml(input) {
+  return String(input)
+    .replace(/<script[\s\S]*?<\/script>/gm, '')
+    .replace(/<style[\s\S]*?<\/style>/gm, '')
+    .replace(/<!--[\s\S]*?-->/gm, '')
+    .replace(/<[^>]+>/g, '');
+}
+
+/**
+ * Word count (Jekyll's number_of_words).
+ * @param {string} input
+ * @returns {number}
+ */
+function numberOfWords(input) {
+  const text = String(input).trim();
+  return text ? text.split(/\s+/).length : 0;
+}
+
+/**
+ * Factory: prefix a path with site.baseurl (Jekyll's relative_url).
+ * @param {object} site - { baseurl }
+ * @returns {function}
+ */
+function createRelativeUrl(site = {}) {
+  return function relativeUrl(input) {
+    const baseurl = String(site.baseurl || '').replace(/\/$/, '');
+    let path = String(input);
+    if (!path.startsWith('/')) path = `/${path}`;
+    return `${baseurl}${path}`;
+  };
+}
+
+/**
+ * Factory: prefix a path with site.url + site.baseurl (Jekyll's absolute_url).
+ * @param {object} site - { url, baseurl }
+ * @returns {function}
+ */
+function createAbsoluteUrl(site = {}) {
+  const relative = createRelativeUrl(site);
+  return function absoluteUrl(input) {
+    if (/^https?:\/\//.test(String(input))) return input;
+    const url = String(site.url || '').replace(/\/$/, '');
+    return `${url}${relative(input)}`;
+  };
+}
+
+/**
+ * Factory: render markdown to HTML. The markdown converter is injected;
+ * without one the input passes through unchanged.
+ * @param {function} [markdown] - (content) => HTML
+ * @returns {function}
+ */
+function createMarkdownify(markdown) {
+  return function markdownify(input) {
+    if (input === null || input === undefined) return '';
+    return markdown ? markdown(String(input)) : String(input);
+  };
+}
+
+/**
+ * Evaluate the supported simple-expression subset against an item, yielding
+ * the expression's VALUE — a comparison yields its boolean, a bare path the
+ * value it points at.
+ * @param {*} item
+ * @param {string} variable - the loop variable name (e.g. "item")
+ * @param {string} expression - e.g. "item.type == 'post'"
+ * @returns {*}
+ */
+function evalExpressionValue(item, variable, expression) {
+  const match = String(expression).trim().match(
+    /^(.+?)\s*(==|!=|>=|<=|>|<|contains)\s*(.+)$/
+  );
+
+  const resolvePath = (pathExpr) => {
+    const trimmed = pathExpr.trim();
+    const literal = trimmed.match(/^["'](.*)["']$/);
+    if (literal) return literal[1];
+    if (trimmed === 'nil' || trimmed === 'null') return null;
+    if (trimmed === 'true') return true;
+    if (trimmed === 'false') return false;
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+
+    const parts = trimmed.split('.');
+    if (parts[0] !== variable) return undefined;
+
+    let current = item;
+    for (const part of parts.slice(1)) {
+      if (current === null || current === undefined) return undefined;
+      current = current[part];
+    }
+    return current;
+  };
+
+  // Bare path — the value it points at (callers decide what to do with it)
+  if (!match) return resolvePath(expression);
+
+  const left = resolvePath(match[1]);
+  const right = resolvePath(match[3]);
+
+  switch (match[2]) {
+    case '==': return left == right; // eslint-disable-line eqeqeq -- Liquid equality is loose
+    case '!=': return left != right; // eslint-disable-line eqeqeq
+    case '>': return left > right;
+    case '<': return left < right;
+    case '>=': return left >= right;
+    case '<=': return left <= right;
+    case 'contains':
+      if (typeof left === 'string') return left.includes(String(right));
+      if (Array.isArray(left)) return left.includes(right);
+      return false;
+    default: return false;
+  }
+}
+
+/**
+ * Keep the items whose expression is truthy (simple-expression subset).
+ * @param {Array} input
+ * @param {string} variable
+ * @param {string} expression
+ * @returns {Array}
+ */
+function whereExp(input, variable, expression) {
+  return [].concat(input || []).filter((item) => {
+    const value = evalExpressionValue(item, variable, expression);
+    return !(value === null || value === undefined || value === false);
+  });
+}
+
+/**
+ * Bucket the items by their expression VALUE — one group per distinct value,
+ * groups in first-seen order, items in input order. An absent value groups
+ * under '' so a rendered group name is never the text "undefined".
+ * @param {Array} input
+ * @param {string} variable
+ * @param {string} expression
+ * @returns {Array<{name: string, items: Array, size: number}>}
+ */
+function groupByExp(input, variable, expression) {
+  const groups = new Map();
+
+  for (const item of [].concat(input || [])) {
+    const value = evalExpressionValue(item, variable, expression);
+    const key = value === null || value === undefined ? '' : String(value);
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(item);
+  }
+
+  return [...groups.entries()].map(([name, items]) => ({ name, items, size: items.length }));
+}
+
+// Context-free compat filters (factories register separately in the adapter)
+const COMPAT_NAMES = {
+  slugify,
+  date_to_xmlschema: dateToXmlschema,
+  date_to_rfc822: dateToRfc822,
+  jsonify,
+  strip_html: stripHtml,
+  number_of_words: numberOfWords,
+  where_exp: whereExp,
+  group_by_exp: groupByExp,
+};
+
+module.exports = {
+  COMPAT_NAMES,
+  slugify,
+  dateToXmlschema,
+  dateToRfc822,
+  jsonify,
+  stripHtml,
+  numberOfWords,
+  whereExp,
+  groupByExp,
+  createRelativeUrl,
+  createAbsoluteUrl,
+  createMarkdownify,
+};

package/dist/vendor/template-kit/tags/collections.js

@@ -0,0 +1,191 @@
+/**
+ * collections.js — the collection-lookup omega_ tags (member, post).
+ *
+ * Ported from jekyll-uj-powertools lib/tags/{member,post}.rb. Collection
+ * access is injected: the adapter provides `ctx.site.getCollection(name)`
+ * returning an array of docs shaped `{ id, url, data }` (Jekyll doc parity —
+ * `id` like '/team/ian' or '/posts/2024-01-01-slug', `data` = frontmatter).
+ * The Ruby's image-tag property re-parsed a {% omega_image %} template; here it
+ * calls the shared buildImageHtml() directly — same output, no re-parse.
+ */
+
+// Libraries
+const { resolveVariable, parseArguments, parseOptions, isQuoted, stripQuotes } = require('../variable-resolver.js');
+const { buildImageHtml } = require('./media.js');
+
+// {% omega_member member_id, "property" %} — look up a team member doc
+const omegaMember = {
+  block: false,
+  render(ctx, markup) {
+    const args = parseArguments(markup);
+    const memberInput = args[0];
+    const property = stripQuotes(args[1] || "'name'");
+
+    const memberId = isQuoted(memberInput)
+      ? stripQuotes(memberInput)
+      : resolveMemberId(ctx, memberInput);
+    if (!memberId) return '';
+
+    const team = ctx.site.getCollection('team') || [];
+    const member = team.find((doc) => String(doc.id).includes(String(memberId)));
+    if (!member) return '';
+
+    const memberData = member.data.member || {};
+
+    switch (property) {
+      case 'name':
+        return memberData.name || '';
+      case 'url': {
+        const siteUrl = ctx.site.config.url || '';
+        return siteUrl + member.url;
+      }
+      case 'path':
+        return member.url;
+      case 'image':
+        return memberImagePath(member);
+      case 'image-tag': {
+        const options = parseOptions(args.slice(2), null);
+        if (!options.alt && memberData.name) options.alt = memberData.name;
+        return buildImageHtml(memberImagePath(member), options);
+      }
+      default:
+        return memberData[property] || member.data[property] || '';
+    }
+  },
+};
+
+function memberImagePath(member) {
+  // Explicit member.image wins (external URL or any asset path — sample
+  // members and CDN-hosted portraits); the team-assets convention stands
+  const memberData = (member.data && member.data.member) || {};
+  if (memberData.image) return memberData.image;
+
+  const cleanId = String(member.id).replace('/team/', '');
+  return `/assets/images/team/${cleanId}/profile.jpg`;
+}
+
+function resolveMemberId(ctx, memberInput) {
+  if (!memberInput) {
+    const page = ctx.page;
+    if (!page) return null;
+
+    if (page.post && page.post.member) return page.post.member;
+    if (page.member && page.member.name) return page.id;
+    return null;
+  }
+  return resolveVariable(ctx.lookup, memberInput);
+}
+
+// {% omega_post post_id, "property" %} — look up a post doc across collections
+const omegaPost = {
+  block: false,
+  render(ctx, markup) {
+    const args = parseArguments(markup);
+    const postInput = args[0];
+    const property = stripQuotes(args[1] || "'title'");
+
+    const postId = isQuoted(postInput)
+      ? stripQuotes(postInput)
+      : resolvePostId(ctx, postInput);
+    if (!postId) return '';
+
+    const post = findPost(ctx.site, postId);
+    if (!post) return '';
+
+    switch (property) {
+      case 'title':
+        return (post.data.post && post.data.post.title) || post.data.title || '';
+      case 'description':
+        return (post.data.post && post.data.post.description) || post.data.description || post.data.excerpt || '';
+      case 'url': {
+        const siteUrl = ctx.site.config.url || '';
+        return siteUrl + post.url;
+      }
+      case 'path':
+        return post.url;
+      case 'date':
+        return formatPostDate(post.data.date);
+      case 'author':
+        return (post.data.post && post.data.post.author) || post.data.author || '';
+      case 'category':
+        return post.data.category || (post.data.categories && post.data.categories[0]) || '';
+      case 'categories':
+        return [].concat(post.data.categories || []).join(', ');
+      case 'tags':
+        return [].concat(post.data.tags || []).join(', ');
+      case 'id':
+        return post.id;
+      case 'image':
+        return postImagePath(post);
+      case 'image-tag': {
+        const src = postImagePath(post);
+        if (!src) return ''; // image: false — deliberately no media
+
+        const options = parseOptions(args.slice(2), ctx.lookup);
+        if (!options.alt) {
+          const defaultAlt = (post.data.post && post.data.post.title) || post.data.title;
+          if (defaultAlt) options.alt = defaultAlt;
+        }
+        return buildImageHtml(src, options);
+      }
+      default:
+        return (post.data.post && post.data.post[property]) || post.data[property] || '';
+    }
+  },
+};
+
+function formatPostDate(date) {
+  if (!date) return '';
+  const parsed = date instanceof Date ? date : new Date(date);
+  if (Number.isNaN(parsed.getTime())) return '';
+  return parsed.toISOString().slice(0, 10);
+}
+
+function postImagePath(post) {
+  // Media contract (same as memberImagePath + the classy includes): an
+  // explicit post.image wins (external URL or any asset path — the sample
+  // posts carry remote heroes), `image: false` means DELIBERATELY no media
+  // (empty — image-tag renders nothing), and the blog-assets convention
+  // stands otherwise.
+  const postData = (post.data && post.data.post) || {};
+  if (postData.image) return postData.image;
+  if (postData.image === false) return '';
+
+  const customId = postData.id || String(post.id).replace(/^\/(\w+)\//, '');
+  const cleanId = String(post.id).replace(/^\/(\w+)\//, '');
+  const slug = cleanId.replace(/^\d{4}-\d{2}-\d{2}-/, '');
+  return `/assets/images/blog/post-${customId}/${slug}.jpg`;
+}
+
+function resolvePostId(ctx, postInput) {
+  if (!postInput) {
+    const page = ctx.page;
+    if (!page) return null;
+
+    if (page.post || page.collection === 'posts') return page.id;
+    return null;
+  }
+  return resolveVariable(ctx.lookup, postInput);
+}
+
+function findPost(site, postId) {
+  const idClean = String(postId).trim();
+  const matches = (doc) =>
+    doc.id === idClean
+    || String(doc.id).includes(idClean)
+    || (doc.data.post && String(doc.data.post.id) === idClean);
+
+  const posts = site.getCollection('posts') || [];
+  const found = posts.find(matches);
+  if (found) return found;
+
+  for (const name of site.getCollectionNames()) {
+    if (name === 'posts') continue;
+    const doc = (site.getCollection(name) || []).find((d) => matches(d) && d.data.post);
+    if (doc) return doc;
+  }
+
+  return null;
+}
+
+module.exports = { omegaMember, omegaPost };

package/dist/vendor/template-kit/tags/conditionals.js

@@ -0,0 +1,101 @@
+/**
+ * conditionals.js — the conditional/control-flow omega_ tags.
+ *
+ * Ported from jekyll-uj-powertools lib/tags/{iftruthy,iffalsy,iffile,urlmatches}.rb.
+ * Each tag is an engine-neutral renderer: `ctx` carries { lookup, page, site }
+ * (built by the engine adapter), `markup` is the raw tag argument string, and
+ * block tags receive `renderInner()` returning their rendered body.
+ */
+
+// Libraries
+const { resolveInput, resolveVariable, parseArguments } = require('../variable-resolver.js');
+
+/**
+ * Truthy check matching the Ruby port: nil/false/''/0 are falsy.
+ * @param {*} value
+ * @returns {boolean}
+ */
+function isTruthy(value) {
+  return !(value === null || value === undefined || value === false || value === '' || value === 0);
+}
+
+// {% iftruthy var %}...{% endiftruthy %}
+const iftruthy = {
+  block: true,
+  render(ctx, markup, renderInner) {
+    const value = resolveInput(ctx.lookup, markup.trim(), false);
+    return isTruthy(value) ? renderInner() : '';
+  },
+};
+
+// {% iffalsy var %}...{% endiffalsy %}
+const iffalsy = {
+  block: true,
+  render(ctx, markup, renderInner) {
+    const value = resolveInput(ctx.lookup, markup.trim(), false);
+    return isTruthy(value) ? '' : renderInner();
+  },
+};
+
+// {% iffile path %}...{% endiffile %} — body renders only if the static file exists
+const iffile = {
+  block: true,
+  render(ctx, markup, renderInner) {
+    let path = resolveFilePath(ctx, markup.trim());
+    if (!path) return '';
+
+    if (!String(path).startsWith('/')) path = `/${path}`;
+    return ctx.site.fileExists(path) ? renderInner() : '';
+  },
+};
+
+/**
+ * Resolve the iffile path argument: quoted = literal; bare tokens resolve as
+ * variables, falling back to the literal markup only when the root segment is
+ * also undefined in context (Ruby parity).
+ */
+function resolveFilePath(ctx, markup) {
+  if (!markup) return null;
+
+  const quoted = markup.match(/^["'](.*)["']$/);
+  if (quoted) return quoted[1];
+
+  const resolved = resolveVariable(ctx.lookup, markup);
+  if (resolved !== null && resolved !== undefined) return resolved;
+
+  const root = markup.split('.')[0];
+  const rootValue = ctx.lookup(root);
+  return (rootValue === null || rootValue === undefined) ? markup : null;
+}
+
+// {% urlmatches "/pricing", "active" %} — outputs arg2 (default "active") when
+// the current page URL matches arg1 (index.html-normalized)
+const urlmatches = {
+  block: false,
+  render(ctx, markup) {
+    const args = parseArguments(markup);
+    const url = args[0] || '';
+    const outputArg = args[1] || 'active';
+
+    const pageUrl = ctx.page ? ctx.page.url : null;
+    const checkUrl = resolveInput(ctx.lookup, url, true);
+    const output = resolveInput(ctx.lookup, outputArg, true);
+
+    return normalizeUrl(pageUrl) === normalizeUrl(checkUrl) ? output : '';
+  },
+};
+
+/**
+ * Normalize a URL for comparison: strip trailing index.html, ensure trailing slash.
+ * @param {string|null} url
+ * @returns {string|null}
+ */
+function normalizeUrl(url) {
+  if (url === null || url === undefined) return null;
+
+  let normalized = String(url).replace(/index\.html?$/, '');
+  if (normalized !== '/' && !normalized.endsWith('/')) normalized += '/';
+  return normalized;
+}
+
+module.exports = { iftruthy, iffalsy, iffile, urlmatches, isTruthy, normalizeUrl };