meno-core 1.0.53 → 1.1.0

package/lib/shared/logger.ts

@@ -0,0 +1,94 @@
+/**
+ * Leveled logger — the single console abstraction for Meno runtime/server code.
+ *
+ * Why: the codebase had hundreds of raw `console.*` calls with no way to gate
+ * verbosity in the field (a packaged desktop app emits everything, with no level
+ * control and no telemetry path). This module adds:
+ *   - levels (silent < error < warn < info < debug), gated by `MENO_LOG_LEVEL`
+ *     (or `NODE_ENV`: `production` → warn, otherwise → debug);
+ *   - per-scope loggers (`createLogger('AstroProvider')`) that prefix messages;
+ *   - a pluggable sink (`setLogSink`) so the Electron main process / telemetry can
+ *     capture logs and crashes instead of (or in addition to) the console.
+ *
+ * Isomorphic: works in Node and the browser. Error reporting still flows through
+ * `errorLogger` (`logRuntimeError`/`logNetworkError`); this is for general
+ * debug/info/warn/error console output.
+ */
+
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+
+const LEVEL_RANK: Record<LogLevel, number> = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+
+/** A record forwarded to the sink for every emitted log line. */
+export interface LogRecord {
+  level: Exclude<LogLevel, 'silent'>;
+  scope: string;
+  message: string;
+  args: unknown[];
+  timestamp: number;
+}
+
+type LogSink = (record: LogRecord) => void;
+
+let sink: LogSink | null = null;
+
+/** Install a sink (telemetry / Electron capture). Pass `null` to remove. */
+export function setLogSink(next: LogSink | null): void {
+  sink = next;
+}
+
+function defaultLevel(): LogLevel {
+  const env = typeof process !== 'undefined' ? process.env : undefined;
+  const explicit = env?.MENO_LOG_LEVEL?.toLowerCase();
+  if (explicit && explicit in LEVEL_RANK) return explicit as LogLevel;
+  return env?.NODE_ENV === 'production' ? 'warn' : 'debug';
+}
+
+let currentLevel: LogLevel = defaultLevel();
+
+/** Override the active level at runtime (e.g. a debug toggle in the app). */
+export function setLogLevel(level: LogLevel): void {
+  currentLevel = level;
+}
+
+/** The active level (resolved from env at module load unless overridden). */
+export function getLogLevel(): LogLevel {
+  return currentLevel;
+}
+
+const CONSOLE: Record<Exclude<LogLevel, 'silent'>, (...a: unknown[]) => void> = {
+  error: (...a) => console.error(...a),
+  warn: (...a) => console.warn(...a),
+  info: (...a) => console.info(...a),
+  debug: (...a) => console.debug(...a),
+};
+
+function emit(level: Exclude<LogLevel, 'silent'>, scope: string, message: string, args: unknown[]): void {
+  if (LEVEL_RANK[level] > LEVEL_RANK[currentLevel]) return;
+  const prefix = scope ? `[${scope}]` : '';
+  CONSOLE[level](`${prefix} ${message}`.trimStart(), ...args);
+  sink?.({ level, scope, message, args, timestamp: Date.now() });
+}
+
+export interface Logger {
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  /** A child logger nested under this scope (`parent:child`). */
+  child(scope: string): Logger;
+}
+
+/** Create a scoped logger. `scope` is prefixed to every line and forwarded to the sink. */
+export function createLogger(scope = ''): Logger {
+  return {
+    debug: (message, ...args) => emit('debug', scope, message, args),
+    info: (message, ...args) => emit('info', scope, message, args),
+    warn: (message, ...args) => emit('warn', scope, message, args),
+    error: (message, ...args) => emit('error', scope, message, args),
+    child: (childScope) => createLogger(scope ? `${scope}:${childScope}` : childScope),
+  };
+}
+
+/** A default unscoped logger for ad-hoc use. Prefer a scoped `createLogger('Area')`. */
+export const logger = createLogger();

package/lib/shared/markdown.ts

@@ -0,0 +1,25 @@
+/**
+ * Markdown → HTML for the `markdown` node type.
+ *
+ * A Meno `markdown` node stores its body as a verbatim Markdown string (`node.source`).
+ * meno-core renders it to HTML here for both the editor canvas (client renderer) and SSR
+ * (design-canvas preview / JSON-format SSR). The meno-astro build runtime has its OWN
+ * `renderMarkdown` (packages/astro/lib/runtime/markdown.ts) — kept separate so a new
+ * meno-core export never has to reach the published Astro play runtime (see the
+ * runtime-uses-npm-meno-core constraint). Both wrap the same `markdown-it` config, so the
+ * canvas preview and the real Astro build render identically.
+ *
+ * `html: true` lets authors embed raw HTML in Markdown (parity with typical Markdown +
+ * the embed node, which also passes author HTML through). Content is author-trusted (the
+ * editor is the source of truth), like the `customCode` / `embed` paths.
+ */
+
+import MarkdownIt from 'markdown-it';
+
+const md = new MarkdownIt({ html: true, linkify: true, breaks: false });
+
+/** Render a Markdown source string to an HTML string. Empty/non-string → "". */
+export function renderMarkdown(source: unknown): string {
+  if (typeof source !== 'string' || source.trim() === '') return '';
+  return md.render(source);
+}

package/lib/shared/netlifyLocale404.test.ts

@@ -0,0 +1,179 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  netlifyLocale404Redirects,
+  syncNetlifyLocale404Block,
+  NETLIFY_LOCALE_404_BEGIN,
+  NETLIFY_LOCALE_404_END,
+} from './netlifyLocale404';
+import type { I18nConfig } from './types';
+
+const MULTI: I18nConfig = {
+  defaultLocale: 'en',
+  locales: [
+    { code: 'en', name: 'EN', nativeName: 'EN', langTag: 'en-US' },
+    { code: 'pl', name: 'PL', nativeName: 'PL', langTag: 'pl-PL' },
+    { code: 'de', name: 'DE', nativeName: 'DE', langTag: 'de-DE' },
+  ],
+};
+
+const EN_PL: I18nConfig = {
+  defaultLocale: 'en',
+  locales: [MULTI.locales[0]!, MULTI.locales[1]!],
+};
+
+const SINGLE: I18nConfig = { defaultLocale: 'en', locales: [MULTI.locales[0]!] };
+
+const BASE_TOML = `# Scaffold generated by Meno.
+[build]
+  command = "npm run build"
+  publish = "dist"
+
+[build.environment]
+  NODE_VERSION = "22"
+`;
+
+describe('netlifyLocale404Redirects (pure generator)', () => {
+  test('one non-shadowing 404 rewrite per non-default locale', () => {
+    const toml = netlifyLocale404Redirects(MULTI);
+    for (const code of ['pl', 'de']) {
+      expect(toml).toContain(`from = "/${code}/*"`);
+      expect(toml).toContain(`to = "/${code}/404/index.html"`);
+    }
+    // status 404 (a rewrite that keeps the URL and the error status — Netlify's
+    // documented localized-404 pattern), never a shadowing force rule.
+    expect(toml.match(/status = 404/g)).toHaveLength(2);
+    expect(toml).not.toContain('force');
+    // The default locale is the root catch-all 404.html — no rule.
+    expect(toml).not.toContain('from = "/en/*"');
+  });
+
+  test('single-locale config → "" (no redirects block at all)', () => {
+    expect(netlifyLocale404Redirects(SINGLE)).toBe('');
+  });
+
+  test('a malformed locale code is skipped (cannot corrupt the TOML)', () => {
+    const sketchy: I18nConfig = {
+      defaultLocale: 'en',
+      locales: [
+        MULTI.locales[0]!,
+        { code: 'pl', name: 'PL', nativeName: 'PL', langTag: 'pl-PL' },
+        { code: 'we"ird/../x', name: 'X', nativeName: 'X', langTag: 'x' },
+      ],
+    };
+    const toml = netlifyLocale404Redirects(sketchy);
+    expect(toml).toContain('from = "/pl/*"');
+    expect(toml).not.toContain('we"ird');
+  });
+
+  test('only-malformed non-default codes → "" (no orphan header)', () => {
+    const allBad: I18nConfig = {
+      defaultLocale: 'en',
+      locales: [MULTI.locales[0]!, { code: 'bad code', name: 'X', nativeName: 'X', langTag: 'x' }],
+    };
+    expect(netlifyLocale404Redirects(allBad)).toBe('');
+  });
+});
+
+describe('syncNetlifyLocale404Block', () => {
+  test('inserts the managed block (multi-locale + 404 page)', () => {
+    const out = syncNetlifyLocale404Block(BASE_TOML, EN_PL, true);
+    // The original content is preserved byte-identically as a prefix.
+    expect(out.startsWith(BASE_TOML)).toBe(true);
+    expect(out).toContain(NETLIFY_LOCALE_404_BEGIN);
+    expect(out).toContain(NETLIFY_LOCALE_404_END);
+    expect(out).toContain('from = "/pl/*"');
+    expect(out).toContain('to = "/pl/404/index.html"');
+    expect(out).toContain('status = 404');
+    expect(out).not.toContain('from = "/en/*"');
+    // The block is line-shaped: BEGIN at line start, END line last, trailing newline.
+    expect(out).toContain(`\n${NETLIFY_LOCALE_404_BEGIN}\n`);
+    expect(out.endsWith(`${NETLIFY_LOCALE_404_END}\n`)).toBe(true);
+  });
+
+  test('adds a trailing newline before appending when the content lacks one', () => {
+    const noTrailing = '[build]\n  publish = "dist"';
+    const out = syncNetlifyLocale404Block(noTrailing, EN_PL, true);
+    expect(out.startsWith(`${noTrailing}\n${NETLIFY_LOCALE_404_BEGIN}\n`)).toBe(true);
+  });
+
+  test('empty content + applicable rules → just the block', () => {
+    const out = syncNetlifyLocale404Block('', EN_PL, true);
+    expect(out.startsWith(NETLIFY_LOCALE_404_BEGIN)).toBe(true);
+    expect(out.endsWith(`${NETLIFY_LOCALE_404_END}\n`)).toBe(true);
+  });
+
+  test('no markers + nothing to add → returned unchanged (single-locale)', () => {
+    expect(syncNetlifyLocale404Block(BASE_TOML, SINGLE, true)).toBe(BASE_TOML);
+  });
+
+  test('no markers + nothing to add → returned unchanged (no 404 page)', () => {
+    expect(syncNetlifyLocale404Block(BASE_TOML, EN_PL, false)).toBe(BASE_TOML);
+  });
+
+  test('idempotent: re-syncing the same state is a no-op', () => {
+    const once = syncNetlifyLocale404Block(BASE_TOML, EN_PL, true);
+    const twice = syncNetlifyLocale404Block(once, EN_PL, true);
+    expect(twice).toBe(once);
+  });
+
+  test('replaces an existing block in place when the locale set changes', () => {
+    const withPl = syncNetlifyLocale404Block(BASE_TOML, EN_PL, true);
+    const withPlDe = syncNetlifyLocale404Block(withPl, MULTI, true);
+    expect(withPlDe).toContain('from = "/pl/*"');
+    expect(withPlDe).toContain('from = "/de/*"');
+    // Exactly one block (replaced, not appended).
+    expect(withPlDe.split(NETLIFY_LOCALE_404_BEGIN)).toHaveLength(2);
+    // Content outside the markers is byte-identical.
+    expect(withPlDe.startsWith(BASE_TOML)).toBe(true);
+    // Replacing pl+de straight away gives the same result (position-stable).
+    expect(withPlDe).toBe(syncNetlifyLocale404Block(BASE_TOML, MULTI, true));
+  });
+
+  test('removes the whole block when the project goes single-locale', () => {
+    const withBlock = syncNetlifyLocale404Block(BASE_TOML, EN_PL, true);
+    const removed = syncNetlifyLocale404Block(withBlock, SINGLE, true);
+    expect(removed).toBe(BASE_TOML); // perfect round-trip
+    expect(removed).not.toContain('[[redirects]]');
+  });
+
+  test('removes the whole block when the 404 page disappears', () => {
+    const withBlock = syncNetlifyLocale404Block(BASE_TOML, EN_PL, true);
+    const removed = syncNetlifyLocale404Block(withBlock, EN_PL, false);
+    expect(removed).toBe(BASE_TOML);
+  });
+
+  test('user content around the block is preserved byte-identically', () => {
+    const userAbove = '# my deploy config\n[build]\n  command = "my build"\n';
+    const userBelow =
+      '\n# user redirect kept verbatim\n[[redirects]]\n  from = "/old"\n  to = "/new"\n  status = 301\n';
+    const withBlock = syncNetlifyLocale404Block(userAbove, EN_PL, true) + userBelow;
+
+    // Replace: outside-the-markers bytes survive.
+    const replaced = syncNetlifyLocale404Block(withBlock, MULTI, true);
+    expect(replaced.startsWith(userAbove)).toBe(true);
+    expect(replaced.endsWith(userBelow)).toBe(true);
+    expect(replaced).toContain('from = "/de/*"');
+
+    // Remove: only the managed lines disappear.
+    const removed = syncNetlifyLocale404Block(withBlock, SINGLE, true);
+    expect(removed).toBe(userAbove + userBelow);
+  });
+
+  test('a corrupted block (BEGIN without END) is left untouched', () => {
+    const corrupt = `${BASE_TOML}${NETLIFY_LOCALE_404_BEGIN}\n# half a block, END deleted by hand\n`;
+    expect(syncNetlifyLocale404Block(corrupt, MULTI, true)).toBe(corrupt);
+    expect(syncNetlifyLocale404Block(corrupt, SINGLE, true)).toBe(corrupt);
+  });
+
+  test('weird locale codes cannot reach the managed block', () => {
+    const sketchy: I18nConfig = {
+      defaultLocale: 'en',
+      locales: [MULTI.locales[0]!, { code: '../escape', name: 'X', nativeName: 'X', langTag: 'x' }],
+    };
+    // Only-malformed codes → no rules → nothing inserted.
+    expect(syncNetlifyLocale404Block(BASE_TOML, sketchy, true)).toBe(BASE_TOML);
+    // And an existing block is removed rather than filled with garbage.
+    const withBlock = syncNetlifyLocale404Block(BASE_TOML, EN_PL, true);
+    expect(syncNetlifyLocale404Block(withBlock, sketchy, true)).toBe(BASE_TOML);
+  });
+});

package/lib/shared/netlifyLocale404.ts

@@ -0,0 +1,110 @@
+/**
+ * Locale-scoped Netlify 404 rules + the managed netlify.toml block that carries them.
+ *
+ * Why: a multi-locale static build emits a localized 404 per non-default locale
+ * (`dist/pl/404/index.html`), but a static host serves exactly ONE catch-all 404
+ * page unless told otherwise — so `/pl/<missing>` would get the default-locale
+ * `404.html`. These rules scope the 404 per locale prefix.
+ *
+ * Shared by every netlify.toml producer — meno-astro's `convertProject` scaffold,
+ * the JSON→Astro export (`build-astro.ts`), the CLI new-project scaffold — and by
+ * the studio save-config route, which re-syncs the managed block when the locale
+ * set changes AFTER the file was first written (so a project that adds a locale
+ * later still gets its rules). It lives in meno-core because the dependency
+ * direction is astro→core: meno-core must never import from meno-astro.
+ */
+
+import type { I18nConfig } from './types';
+
+/**
+ * First line of the managed block. Everything between the markers (inclusive) is
+ * generated and may be rewritten wholesale by `syncNetlifyLocale404Block`; user
+ * content outside the markers is never touched.
+ */
+export const NETLIFY_LOCALE_404_BEGIN = '# BEGIN meno locale-404 redirects (generated — do not edit between markers)';
+
+/** Last line of the managed block. */
+export const NETLIFY_LOCALE_404_END = '# END meno locale-404 redirects';
+
+/**
+ * Locale-scoped 404 rules for a netlify.toml — one `[[redirects]]` block per
+ * non-default locale (`''` for single-locale configs):
+ *
+ *   [[redirects]]
+ *     from = "/pl/*"
+ *     to = "/pl/404/index.html"
+ *     status = 404
+ *
+ * Netlify semantics (verified against Netlify's "redirect options" docs, the
+ * documented "localized custom 404" pattern): a redirect with `status = 404` and no
+ * `force` is a NON-SHADOWING rewrite — a request that matches an existing file is
+ * served normally (real `/pl/...` pages always win), and only an unmatched `/pl/*`
+ * URL serves the `to` file's CONTENT with an HTTP 404 status (the URL stays put; no
+ * 3xx). Everything the rules don't cover falls through to Netlify's root convention:
+ * a top-level `404.html` (which Astro builds from `src/pages/404.astro`) is served
+ * automatically for any other unmatched URL — no explicit catch-all rule needed.
+ *
+ * Locale codes are sanity-checked (`/^[A-Za-z0-9_-]+$/`): a malformed code would
+ * corrupt the TOML / redirect syntax, and such a locale cannot produce a route anyway.
+ *
+ * Pure (config in, TOML fragment out) so it is directly unit-testable; callers own
+ * the existence gates (404 page present, netlify.toml ownership). Most callers
+ * should go through `syncNetlifyLocale404Block`, which wraps the rules in the
+ * managed marker block so later config saves can update them in place.
+ */
+export function netlifyLocale404Redirects(config: I18nConfig): string {
+  if (!config.locales || config.locales.length <= 1) return '';
+  const codes = config.locales
+    .map((l) => l.code)
+    .filter((code) => code !== config.defaultLocale && /^[A-Za-z0-9_-]+$/.test(code));
+  if (codes.length === 0) return '';
+  const header =
+    "\n# Locale-scoped 404s — an unmatched /<locale>/* URL serves that locale's own\n" +
+    '# prerendered 404 page WITH a 404 status (non-shadowing: real pages still win).\n' +
+    '# Unmatched URLs outside these prefixes fall through to the default /404.html.\n';
+  const rules = codes
+    .map((code) => `[[redirects]]\n  from = "/${code}/*"\n  to = "/${code}/404/index.html"\n  status = 404\n`)
+    .join('\n');
+  return header + rules;
+}
+
+/**
+ * Insert / refresh / remove the managed locale-404 block in netlify.toml content.
+ * Pure (string in, string out) — callers own reading/writing the file.
+ *
+ *  - Rules applicable (multi-locale config AND `has404`) + no block yet → the block
+ *    is APPENDED (a trailing newline is added to the existing content first if it
+ *    lacks one).
+ *  - Rules applicable + block present → the block's contents are REPLACED in place
+ *    (idempotent: re-syncing identical state is a no-op).
+ *  - Rules no longer applicable (single-locale, or no 404 page) + block present →
+ *    the whole block is REMOVED; everything outside the markers stays byte-identical.
+ *  - Nothing applicable + no block → the content is returned unchanged.
+ *
+ * A corrupted block (BEGIN marker without its END) is left untouched — rewriting up
+ * to an unknown boundary could eat user content, and a hand-damaged block is the
+ * user taking ownership.
+ */
+export function syncNetlifyLocale404Block(content: string, config: I18nConfig, has404: boolean): string {
+  const rules = has404 ? netlifyLocale404Redirects(config) : '';
+  // `rules` starts with '\n' (terminating the BEGIN line) and ends with '\n'
+  // (putting END at line start), so the block is exactly BEGIN…rules…END lines.
+  const block = rules ? `${NETLIFY_LOCALE_404_BEGIN}${rules}${NETLIFY_LOCALE_404_END}\n` : '';
+
+  const beginIdx = content.indexOf(NETLIFY_LOCALE_404_BEGIN);
+  if (beginIdx === -1) {
+    if (!block) return content;
+    const base = content === '' || content.endsWith('\n') ? content : `${content}\n`;
+    return base + block;
+  }
+
+  const endMarkerIdx = content.indexOf(NETLIFY_LOCALE_404_END, beginIdx);
+  if (endMarkerIdx === -1) return content; // corrupted block — refuse to guess its extent
+
+  let endIdx = endMarkerIdx + NETLIFY_LOCALE_404_END.length;
+  if (content[endIdx] === '\n') endIdx += 1; // the END line's own newline belongs to the block
+
+  const before = content.slice(0, beginIdx);
+  const after = content.slice(endIdx);
+  return before + block + after;
+}

package/lib/shared/nodeUtils.test.ts

@@ -24,7 +24,7 @@ import {
   isEmptyContainer,
 } from './nodeUtils';
 import { NODE_TYPE } from './constants';
-import type { ComponentNode, ComponentInstanceNode, HtmlNode, SlotMarker, EmbedNode, LinkNode, LocaleListNode } from './types';
+import type { ComponentInstanceNode, HtmlNode, SlotMarker, EmbedNode, LinkNode, LocaleListNode } from './types';
 import { registerBuiltInNodeTypes } from './registry';
 
 describe('nodeUtils', () => {
@@ -126,11 +126,11 @@ describe('nodeUtils', () => {
       const node: ComponentInstanceNode = {
         type: NODE_TYPE.COMPONENT,
         component: 'Button',
-        props: { text: 'Click me' }
+        props: { text: 'Click me' },
       };
       expect(extractNodeProperties(node)).toEqual({
         componentName: 'Button',
-        props: { text: 'Click me' }
+        props: { text: 'Click me' },
       });
     });
 
@@ -138,7 +138,7 @@ describe('nodeUtils', () => {
       const node: HtmlNode = { type: NODE_TYPE.NODE, tag: 'div' };
       expect(extractNodeProperties(node)).toEqual({
         tag: 'div',
-        props: {}
+        props: {},
       });
     });
 
@@ -227,6 +227,10 @@ describe('nodeUtils', () => {
       expect(isValidNodeType(NODE_TYPE.EMBED)).toBe(true);
       expect(isValidNodeType(NODE_TYPE.LINK)).toBe(true);
       expect(isValidNodeType(NODE_TYPE.LOCALE_LIST)).toBe(true);
+      expect(isValidNodeType(NODE_TYPE.LIST)).toBe(true);
+      expect(isValidNodeType(NODE_TYPE.ISLAND)).toBe(true);
+      expect(isValidNodeType(NODE_TYPE.CUSTOM)).toBe(true);
+      expect(isValidNodeType(NODE_TYPE.MARKDOWN)).toBe(true);
     });
 
     test('returns false for invalid node types', () => {
@@ -253,6 +257,14 @@ describe('nodeUtils', () => {
       expect(canHaveChildren(null)).toBe(false);
       expect(canHaveChildren(undefined)).toBe(false);
     });
+
+    test('returns false for a verbatim {_code} marker (the emitter ignores children → silent loss)', () => {
+      expect(
+        canHaveChildren({ _code: true, expr: 'items.map((i) => i)' } as unknown as Parameters<
+          typeof canHaveChildren
+        >[0]),
+      ).toBe(false);
+    });
   });
 
   describe('canHaveStyle', () => {
@@ -328,7 +340,7 @@ describe('nodeUtils', () => {
       const mapping = {
         _mapping: true,
         prop: 'visible',
-        values: { 'true': true, 'false': false }
+        values: { true: true, false: false },
       };
       expect(isBooleanMapping(mapping)).toBe(true);
     });
@@ -368,8 +380,8 @@ describe('nodeUtils', () => {
         if: {
           _mapping: true,
           prop: 'showBanner',
-          values: { 'true': true, 'false': false }
-        }
+          values: { true: true, false: false },
+        },
       } as any;
 
       expect(evaluateNodeIf(node, { showBanner: 'true' })).toBe(true);
@@ -383,8 +395,8 @@ describe('nodeUtils', () => {
         if: {
           _mapping: true,
           prop: 'status',
-          values: { 'active': true, 'inactive': false }
-        }
+          values: { active: true, inactive: false },
+        },
       } as any;
 
       // 'unknown' is not in the values map
@@ -398,8 +410,8 @@ describe('nodeUtils', () => {
         if: {
           _mapping: true,
           prop: 'visible',
-          values: { 'true': true, 'false': false }
-        }
+          values: { true: true, false: false },
+        },
       } as any;
 
       expect(evaluateNodeIf(node)).toBe(true);
@@ -409,7 +421,7 @@ describe('nodeUtils', () => {
       const node = {
         type: NODE_TYPE.NODE,
         tag: 'div',
-        if: '{{showBanner}}'
+        if: '{{showBanner}}',
       } as any;
 
       // String templates can't be resolved without context, default to true
@@ -420,7 +432,7 @@ describe('nodeUtils', () => {
       const node: ComponentInstanceNode = {
         type: NODE_TYPE.COMPONENT,
         component: 'Banner',
-        if: false
+        if: false,
       } as any;
       expect(evaluateNodeIf(node)).toBe(false);
     });
@@ -429,7 +441,7 @@ describe('nodeUtils', () => {
       const node: EmbedNode = {
         type: NODE_TYPE.EMBED,
         html: '<svg></svg>',
-        if: false
+        if: false,
       } as any;
       expect(evaluateNodeIf(node)).toBe(false);
     });
@@ -438,7 +450,7 @@ describe('nodeUtils', () => {
       const node: LinkNode = {
         type: NODE_TYPE.LINK,
         href: '/page',
-        if: true
+        if: true,
       } as any;
       expect(evaluateNodeIf(node)).toBe(true);
     });
@@ -515,7 +527,7 @@ describe('nodeUtils', () => {
       const node: HtmlNode = {
         type: NODE_TYPE.NODE,
         tag: 'div',
-        children: [{ type: NODE_TYPE.NODE, tag: 'span' }]
+        children: [{ type: NODE_TYPE.NODE, tag: 'span' }],
       };
       expect(isEmptyContainer(node)).toBe(false);
     });