@bytefaceinc/web-lang 0.1.1

package/lib/cli/targets.js

@@ -0,0 +1,199 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function inferDefaultCompileTargets(workingDirectory) {
+  const layoutPath = path.join(workingDirectory, 'layout.web');
+  return fs.existsSync(layoutPath) ? ['layout.web'] : [];
+}
+
+function resolveTargets(rawTargets, workingDirectory) {
+  const files = [];
+  const errors = [];
+  const seen = new Set();
+
+  for (const rawTarget of rawTargets) {
+    const resolution = resolveTarget(rawTarget, workingDirectory);
+
+    if (resolution.error) {
+      errors.push(resolution.error);
+      continue;
+    }
+
+    for (const file of resolution.files) {
+      if (seen.has(file)) {
+        continue;
+      }
+
+      seen.add(file);
+      files.push(file);
+    }
+  }
+
+  files.sort((left, right) => left.localeCompare(right));
+
+  return { files, errors };
+}
+
+function resolveTarget(rawTarget, workingDirectory) {
+  if (hasGlobMagic(rawTarget)) {
+    const matches = expandGlob(rawTarget, workingDirectory);
+    return normalizeResolvedMatches(rawTarget, matches);
+  }
+
+  if (rawTarget !== '.' && rawTarget !== '..' && path.extname(rawTarget) === '') {
+    const extensionCandidate = path.resolve(workingDirectory, `${rawTarget}.web`);
+
+    if (isFile(extensionCandidate)) {
+      return {
+        files: [extensionCandidate],
+      };
+    }
+  }
+
+  const resolvedPath = path.resolve(workingDirectory, rawTarget);
+
+  if (!fs.existsSync(resolvedPath)) {
+    return {
+      error: `No WEB source matched "${rawTarget}".`,
+    };
+  }
+
+  return normalizeResolvedMatches(rawTarget, [resolvedPath]);
+}
+
+function normalizeResolvedMatches(rawTarget, matches) {
+  const files = [];
+
+  for (const match of matches) {
+    if (!fs.existsSync(match)) {
+      continue;
+    }
+
+    const stats = fs.statSync(match);
+
+    if (stats.isDirectory()) {
+      files.push(...listWebFilesInDirectory(match));
+      continue;
+    }
+
+    if (stats.isFile() && path.extname(match).toLowerCase() === '.web') {
+      files.push(path.resolve(match));
+    }
+  }
+
+  if (files.length === 0) {
+    return {
+      error: `No .web files found for "${rawTarget}".`,
+    };
+  }
+
+  return {
+    files,
+  };
+}
+
+function listWebFilesInDirectory(directoryPath) {
+  return fs
+    .readdirSync(directoryPath, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && path.extname(entry.name).toLowerCase() === '.web')
+    .map((entry) => path.join(directoryPath, entry.name))
+    .sort((left, right) => left.localeCompare(right));
+}
+
+function expandGlob(pattern, workingDirectory) {
+  const absolutePattern = path.resolve(workingDirectory, pattern);
+  const root = path.parse(absolutePattern).root;
+  const relativePattern = absolutePattern.slice(root.length);
+  const segments = relativePattern.split(path.sep).filter(Boolean);
+  return walkGlob(root, segments, 0);
+}
+
+function walkGlob(currentPath, segments, index) {
+  if (index >= segments.length) {
+    return [currentPath];
+  }
+
+  const segment = segments[index];
+
+  if (!hasGlobMagic(segment)) {
+    const nextPath = path.join(currentPath, segment);
+    return fs.existsSync(nextPath) ? walkGlob(nextPath, segments, index + 1) : [];
+  }
+
+  if (!fs.existsSync(currentPath) || !fs.statSync(currentPath).isDirectory()) {
+    return [];
+  }
+
+  const matcher = globSegmentToRegExp(segment);
+  const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+  const matches = [];
+
+  for (const entry of entries) {
+    if (!segment.startsWith('.') && entry.name.startsWith('.')) {
+      continue;
+    }
+
+    if (!matcher.test(entry.name)) {
+      continue;
+    }
+
+    matches.push(...walkGlob(path.join(currentPath, entry.name), segments, index + 1));
+  }
+
+  return matches;
+}
+
+function globSegmentToRegExp(segment) {
+  let pattern = '^';
+
+  for (let index = 0; index < segment.length; index += 1) {
+    const char = segment[index];
+
+    if (char === '*') {
+      pattern += '.*';
+      continue;
+    }
+
+    if (char === '?') {
+      pattern += '.';
+      continue;
+    }
+
+    if (char === '[') {
+      const closingIndex = segment.indexOf(']', index + 1);
+
+      if (closingIndex === -1) {
+        pattern += '\\[';
+        continue;
+      }
+
+      pattern += segment.slice(index, closingIndex + 1);
+      index = closingIndex;
+      continue;
+    }
+
+    pattern += escapeRegExp(char);
+  }
+
+  pattern += '$';
+  return new RegExp(pattern);
+}
+
+function hasGlobMagic(value) {
+  return /[*?[]/.test(value);
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
+}
+
+function isFile(filePath) {
+  return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+}
+
+module.exports = {
+  inferDefaultCompileTargets,
+  resolveTargets,
+};

package/lib/cli/watch-settings.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const DEFAULT_WATCH_DEBOUNCE_MS = 180;
+const DEFAULT_WATCH_IDLE_TIMEOUT_MS = 60 * 60 * 1000;
+const DEFAULT_WATCH_POLL_INTERVAL_MS = 250;
+const DEFAULT_WATCH_SCREENSHOT_INTERVAL_MS = 5 * 60 * 1000;
+
+function getWatchRuntimeSettings(env = process.env) {
+  return {
+    debounceMs: readPositiveInteger(env.WEB_LANG_WATCH_DEBOUNCE_MS, DEFAULT_WATCH_DEBOUNCE_MS),
+    idleTimeoutMs: readPositiveInteger(env.WEB_LANG_WATCH_IDLE_TIMEOUT_MS, DEFAULT_WATCH_IDLE_TIMEOUT_MS),
+    pollIntervalMs: readPositiveInteger(env.WEB_LANG_WATCH_POLL_INTERVAL_MS, DEFAULT_WATCH_POLL_INTERVAL_MS),
+    screenshotIntervalMs: readPositiveInteger(env.WEB_LANG_WATCH_SCREENSHOT_INTERVAL_MS, DEFAULT_WATCH_SCREENSHOT_INTERVAL_MS),
+  };
+}
+
+function readPositiveInteger(rawValue, fallback) {
+  if (rawValue === undefined || rawValue === null || rawValue === '') {
+    return fallback;
+  }
+
+  const parsedValue = Number(rawValue);
+
+  if (!Number.isInteger(parsedValue) || parsedValue <= 0) {
+    return fallback;
+  }
+
+  return parsedValue;
+}
+
+module.exports = {
+  DEFAULT_WATCH_DEBOUNCE_MS,
+  DEFAULT_WATCH_IDLE_TIMEOUT_MS,
+  DEFAULT_WATCH_POLL_INTERVAL_MS,
+  DEFAULT_WATCH_SCREENSHOT_INTERVAL_MS,
+  getWatchRuntimeSettings,
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@bytefaceinc/web-lang",
+  "version": "0.1.1",
+  "description": "WEB Lang compiler and CLI for authoring .web power docs that compile to HTML, CSS, render screenshots, and support watch mode",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "./compiler.js",
+  "exports": {
+    ".": "./compiler.js",
+    "./compiler": "./compiler.js"
+  },
+  "bin": {
+    "web": "bin/web.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "compiler.js",
+    "bin/",
+    "lib/",
+    "docs/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "web-lang",
+    "web",
+    "compiler",
+    "cli",
+    "dsl",
+    "html",
+    "css",
+    "screenshot",
+    "watch",
+    "puppeteer",
+    "static-site",
+    "design-system"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "puppeteer": "^24.40.0"
+  },
+  "scripts": {
+    "test": "node smoke-test.js",
+    "pack:check": "npm pack --dry-run"
+  }
+}