@flare-desktop/cli 0.0.0-stage → 0.1.1

package/src/lib/png.js

@@ -0,0 +1,288 @@
+import { deflateSync, inflateSync } from "node:zlib";
+
+import { FlareError } from "./errors.js";
+
+const SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const COLOR_CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+
+const crcTable = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < 256; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+})();
+
+function crc32(buffer) {
+  let crc = 0xffffffff;
+  for (const byte of buffer) crc = crcTable[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function chunk(type, data) {
+  const header = Buffer.alloc(8);
+  header.writeUInt32BE(data.length, 0);
+  header.write(type, 4, 4, "ascii");
+  const checksum = Buffer.alloc(4);
+  checksum.writeUInt32BE(crc32(Buffer.concat([header.subarray(4), data])), 0);
+  return Buffer.concat([header, data, checksum]);
+}
+
+function paeth(left, up, upperLeft) {
+  const estimate = left + up - upperLeft;
+  const leftDistance = Math.abs(estimate - left);
+  const upDistance = Math.abs(estimate - up);
+  const upperLeftDistance = Math.abs(estimate - upperLeft);
+  if (leftDistance <= upDistance && leftDistance <= upperLeftDistance) return left;
+  if (upDistance <= upperLeftDistance) return up;
+  return upperLeft;
+}
+
+function unfilter(raw, width, height, bytesPerPixel) {
+  const stride = width * bytesPerPixel;
+  const pixels = Buffer.alloc(stride * height);
+  let offset = 0;
+
+  for (let y = 0; y < height; y += 1) {
+    const filter = raw[offset];
+    offset += 1;
+    const row = pixels.subarray(y * stride, (y + 1) * stride);
+    const previous = y > 0 ? pixels.subarray((y - 1) * stride, y * stride) : null;
+
+    for (let x = 0; x < stride; x += 1) {
+      const value = raw[offset + x];
+      const left = x >= bytesPerPixel ? row[x - bytesPerPixel] : 0;
+      const up = previous ? previous[x] : 0;
+      const upperLeft = previous && x >= bytesPerPixel ? previous[x - bytesPerPixel] : 0;
+
+      if (filter === 0) row[x] = value;
+      else if (filter === 1) row[x] = (value + left) & 0xff;
+      else if (filter === 2) row[x] = (value + up) & 0xff;
+      else if (filter === 3) row[x] = (value + ((left + up) >> 1)) & 0xff;
+      else if (filter === 4) row[x] = (value + paeth(left, up, upperLeft)) & 0xff;
+      else throw new FlareError(`unsupported png filter ${filter}`);
+    }
+
+    offset += stride;
+  }
+
+  return pixels;
+}
+
+function toRgba(pixels, header, palette, transparency) {
+  const { width, height, colorType } = header;
+  const data = Buffer.alloc(width * height * 4);
+
+  for (let index = 0; index < width * height; index += 1) {
+    const target = index * 4;
+    if (colorType === 0) {
+      const value = pixels[index];
+      data[target] = value;
+      data[target + 1] = value;
+      data[target + 2] = value;
+      data[target + 3] = 255;
+      continue;
+    }
+    if (colorType === 2) {
+      data[target] = pixels[index * 3];
+      data[target + 1] = pixels[index * 3 + 1];
+      data[target + 2] = pixels[index * 3 + 2];
+      data[target + 3] = 255;
+      continue;
+    }
+    if (colorType === 3) {
+      if (!palette) throw new FlareError("png palette is missing");
+      const entry = pixels[index];
+      data[target] = palette[entry * 3] ?? 0;
+      data[target + 1] = palette[entry * 3 + 1] ?? 0;
+      data[target + 2] = palette[entry * 3 + 2] ?? 0;
+      data[target + 3] = transparency?.[entry] ?? 255;
+      continue;
+    }
+    if (colorType === 4) {
+      const value = pixels[index * 2];
+      data[target] = value;
+      data[target + 1] = value;
+      data[target + 2] = value;
+      data[target + 3] = pixels[index * 2 + 1];
+      continue;
+    }
+    data[target] = pixels[index * 4];
+    data[target + 1] = pixels[index * 4 + 1];
+    data[target + 2] = pixels[index * 4 + 2];
+    data[target + 3] = pixels[index * 4 + 3];
+  }
+
+  return data;
+}
+
+export function readPng(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 8 || !buffer.subarray(0, 8).equals(SIGNATURE)) {
+    throw new FlareError("not a png file");
+  }
+
+  let offset = 8;
+  let header = null;
+  let palette = null;
+  let transparency = null;
+  const chunks = [];
+
+  while (offset + 12 <= buffer.length) {
+    const length = buffer.readUInt32BE(offset);
+    const type = buffer.toString("ascii", offset + 4, offset + 8);
+    const data = buffer.subarray(offset + 8, offset + 8 + length);
+    offset += length + 12;
+
+    if (type === "IHDR") {
+      header = {
+        width: data.readUInt32BE(0),
+        height: data.readUInt32BE(4),
+        bitDepth: data[8],
+        colorType: data[9],
+        compression: data[10],
+        filter: data[11],
+        interlace: data[12]
+      };
+    } else if (type === "PLTE") {
+      palette = Buffer.from(data);
+    } else if (type === "tRNS") {
+      transparency = Buffer.from(data);
+    } else if (type === "IDAT") {
+      chunks.push(Buffer.from(data));
+    } else if (type === "IEND") {
+      break;
+    }
+  }
+
+  if (!header) throw new FlareError("png header is missing");
+  if (header.bitDepth !== 8) throw new FlareError("only 8 bit png images are supported");
+  if (header.compression !== 0) throw new FlareError("unsupported png compression");
+  if (header.filter !== 0) throw new FlareError("unsupported png filter method");
+  if (header.interlace !== 0) throw new FlareError("interlaced png images are not supported");
+  if (!COLOR_CHANNELS[header.colorType]) throw new FlareError(`unsupported png color type ${header.colorType}`);
+  if (header.width <= 0 || header.height <= 0) throw new FlareError("png image is empty");
+  if (chunks.length === 0) throw new FlareError("png image data is missing");
+
+  const bytesPerPixel = COLOR_CHANNELS[header.colorType];
+  const raw = inflateSync(Buffer.concat(chunks));
+  const expected = header.height * (header.width * bytesPerPixel + 1);
+  if (raw.length < expected) throw new FlareError("png image data is truncated");
+
+  const pixels = unfilter(raw, header.width, header.height, bytesPerPixel);
+  return {
+    width: header.width,
+    height: header.height,
+    data: toRgba(pixels, header, palette, transparency)
+  };
+}
+
+export function writePng(image) {
+  const { width, height, data } = image;
+  if (width <= 0 || height <= 0) throw new FlareError("cannot encode an empty image");
+  if (data.length !== width * height * 4) throw new FlareError("pixel buffer does not match the image size");
+
+  const stride = width * 4;
+  const raw = Buffer.alloc((stride + 1) * height);
+  for (let y = 0; y < height; y += 1) {
+    raw[y * (stride + 1)] = 0;
+    data.copy(raw, y * (stride + 1) + 1, y * stride, (y + 1) * stride);
+  }
+
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(width, 0);
+  header.writeUInt32BE(height, 4);
+  header[8] = 8;
+  header[9] = 6;
+  header[10] = 0;
+  header[11] = 0;
+  header[12] = 0;
+
+  return Buffer.concat([
+    SIGNATURE,
+    chunk("IHDR", header),
+    chunk("IDAT", deflateSync(raw, { level: 9 })),
+    chunk("IEND", Buffer.alloc(0))
+  ]);
+}
+
+function sampleBilinear(image, x, y) {
+  const { width, height, data } = image;
+  const left = Math.max(0, Math.min(width - 1, Math.floor(x)));
+  const top = Math.max(0, Math.min(height - 1, Math.floor(y)));
+  const right = Math.max(0, Math.min(width - 1, left + 1));
+  const bottom = Math.max(0, Math.min(height - 1, top + 1));
+  const xWeight = Math.max(0, Math.min(1, x - left));
+  const yWeight = Math.max(0, Math.min(1, y - top));
+  const result = [0, 0, 0, 0];
+
+  for (let channel = 0; channel < 4; channel += 1) {
+    const topLeft = data[(top * width + left) * 4 + channel];
+    const topRight = data[(top * width + right) * 4 + channel];
+    const bottomLeft = data[(bottom * width + left) * 4 + channel];
+    const bottomRight = data[(bottom * width + right) * 4 + channel];
+    const upper = topLeft + (topRight - topLeft) * xWeight;
+    const lower = bottomLeft + (bottomRight - bottomLeft) * xWeight;
+    result[channel] = upper + (lower - upper) * yWeight;
+  }
+
+  return result;
+}
+
+export function resizePng(image, width, height) {
+  if (width <= 0 || height <= 0) throw new FlareError("cannot resize an image to an empty size");
+  if (image.width === width && image.height === height) {
+    return { width, height, data: Buffer.from(image.data) };
+  }
+
+  const data = Buffer.alloc(width * height * 4);
+  const scaleX = image.width / width;
+  const scaleY = image.height / height;
+
+  if (scaleX >= 1 && scaleY >= 1) {
+    for (let y = 0; y < height; y += 1) {
+      const fromY = Math.floor(y * scaleY);
+      const toY = Math.max(fromY + 1, Math.min(image.height, Math.ceil((y + 1) * scaleY)));
+      for (let x = 0; x < width; x += 1) {
+        const fromX = Math.floor(x * scaleX);
+        const toX = Math.max(fromX + 1, Math.min(image.width, Math.ceil((x + 1) * scaleX)));
+        const total = [0, 0, 0, 0];
+        let count = 0;
+        for (let sourceY = fromY; sourceY < toY; sourceY += 1) {
+          for (let sourceX = fromX; sourceX < toX; sourceX += 1) {
+            const source = (sourceY * image.width + sourceX) * 4;
+            total[0] += image.data[source];
+            total[1] += image.data[source + 1];
+            total[2] += image.data[source + 2];
+            total[3] += image.data[source + 3];
+            count += 1;
+          }
+        }
+        const target = (y * width + x) * 4;
+        data[target] = Math.round(total[0] / count);
+        data[target + 1] = Math.round(total[1] / count);
+        data[target + 2] = Math.round(total[2] / count);
+        data[target + 3] = Math.round(total[3] / count);
+      }
+    }
+    return { width, height, data };
+  }
+
+  for (let y = 0; y < height; y += 1) {
+    const sourceY = (y + 0.5) * scaleY - 0.5;
+    for (let x = 0; x < width; x += 1) {
+      const sourceX = (x + 0.5) * scaleX - 0.5;
+      const pixel = sampleBilinear(image, sourceX, sourceY);
+      const target = (y * width + x) * 4;
+      data[target] = Math.round(pixel[0]);
+      data[target + 1] = Math.round(pixel[1]);
+      data[target + 2] = Math.round(pixel[2]);
+      data[target + 3] = Math.round(pixel[3]);
+    }
+  }
+
+  return { width, height, data };
+}

package/src/lib/process.js

@@ -0,0 +1,57 @@
+import { spawn, spawnSync } from "node:child_process";
+
+import { FlareError } from "./errors.js";
+
+export function run(command, args = [], { cwd, env, stdio = "inherit", shell = false } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: env ? { ...process.env, ...env } : process.env,
+      stdio,
+      shell
+    });
+    child.on("error", reject);
+    child.on("close", (code, signal) => resolve({ code: code ?? 1, signal }));
+  });
+}
+
+export function startShell(command, { cwd, env } = {}) {
+  return spawn(command, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    shell: true,
+    stdio: "inherit",
+    detached: process.platform !== "win32"
+  });
+}
+
+export async function runShell(command, { cwd, env, stdio = "inherit" } = {}) {
+  return run(command, [], { cwd, env, stdio, shell: true });
+}
+
+export async function runChecked(command, args, options = {}) {
+  const result = await run(command, args, options);
+  if (result.code !== 0) throw new FlareError(`'${command}' exited with code ${result.code}`);
+  return result;
+}
+
+export function capture(command, args = [], options = {}) {
+  return spawnSync(command, args, { encoding: "utf8", ...options });
+}
+
+export function firstLine(text) {
+  return String(text ?? "").split(/\r?\n/)[0].trim();
+}
+
+export function terminate(child) {
+  if (!child || child.exitCode !== null) return;
+  if (process.platform === "win32") {
+    spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+  } catch {
+    child.kill("SIGTERM");
+  }
+}

package/src/lib/project.js

@@ -0,0 +1,285 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+import { FlareError } from "./errors.js";
+import { SCHEMA_URL } from "../schema.js";
+
+export const DEFAULT_CONFIG_FILE = "flare.config.json";
+export const DEFAULT_SCHEMA_URL = SCHEMA_URL;
+export { SCHEMA_URL };
+
+const SEMVER = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+const APP_NAME = /^[a-z][a-z0-9-_]*$/;
+
+export function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function platformName(platform = process.platform) {
+  if (platform === "win32") return "windows";
+  if (platform === "darwin") return "macos";
+  if (platform === "linux") return "linux";
+  return platform;
+}
+
+export function platformDisplayName(platform = process.platform) {
+  if (platform === "win32") return "Windows";
+  if (platform === "darwin") return "macOS";
+  if (platform === "linux") return "Linux";
+  return platform;
+}
+
+export function architectureName(architecture = process.arch) {
+  if (architecture === "x64") return "x86_64";
+  if (architecture === "arm64") return "aarch64";
+  if (architecture === "ia32") return "x86";
+  return architecture;
+}
+
+export function formatsForPlatform(platform = process.platform) {
+  if (platform === "linux") return ["deb", "rpm", "appimage"];
+  if (platform === "darwin") return ["app", "dmg"];
+  if (platform === "win32") return ["msi", "nsis"];
+  return [];
+}
+
+export function toKebabCase(value) {
+  const normalized = String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-{2,}/g, "-");
+  return normalized || "flare-app";
+}
+
+export function isValidAppName(name) {
+  return APP_NAME.test(String(name));
+}
+
+export function defaults(identifier, version) {
+  return {
+    $schema: SCHEMA_URL,
+    package: { productName: "flare-app", version },
+    app: {
+      identifier,
+      productName: "flare-app",
+      mainBinaryName: "flare-app",
+      version
+    },
+    build: {
+      beforeDevCommand: "",
+      afterDevCommand: "",
+      beforeBuildCommand: "",
+      afterBuildCommand: "",
+      frontendDist: "frontend",
+      devUrl: "",
+      removeUnusedCommands: [],
+      features: {
+        customProtocol: true,
+        devtools: false,
+        isolation: false,
+        systemTray: false
+      }
+    },
+    bundle: {
+      active: true,
+      identifier,
+      icon: "icons/icon.png",
+      version,
+      publisher: "",
+      homepage: "",
+      longDescription: "",
+      shortDescription: "",
+      copyright: "",
+      category: "DeveloperTool",
+      licenseFile: "",
+      targets: [],
+      resources: [],
+      externalBin: [],
+      linux: { depends: "", desktopTemplate: "", section: "utils", priority: "optional", files: [] },
+      windows: { language: "en-US", installerIcon: "", installMode: 0, webviewInstallModeOffline: false },
+      macos: { minimumSystemVersion: "10.15", frameworks: false, signingIdentity: "" }
+    },
+    security: {
+      freezePrototype: true,
+      dangerousDisableAssetCspModification: false,
+      dangerousUseHttpScheme: false,
+      dangerousAcceptInvalidCertificates: false,
+      capabilities: [],
+      dangerousRemoteDomainIpcAccess: []
+    },
+    windows: [
+      {
+        label: "main",
+        title: "flare-app",
+        width: 800,
+        height: 600,
+        minimumSize: { width: 0, height: 0 },
+        maximumSize: { width: 0, height: 0 },
+        resizable: true,
+        maximized: false,
+        fullscreen: false,
+        alwaysOnTop: false,
+        decorations: true,
+        transparent: false,
+        visible: true,
+        center: true,
+        devtools: false,
+        theme: "automatic"
+      }
+    ],
+    plugins: {}
+  };
+}
+
+export function layerFileNames(configFile, environment) {
+  const extension = path.extname(configFile) || ".json";
+  const stem = path.basename(configFile, extension);
+  return [
+    `${stem}.${platformName()}${extension}`,
+    ...(environment ? [`${stem}.${environment}${extension}`] : []),
+    `${stem}.local${extension}`
+  ];
+}
+
+export function resolveConfigFiles(projectDirectory, { configFile = DEFAULT_CONFIG_FILE, environment = "" } = {}) {
+  const base = path.isAbsolute(configFile) ? configFile : path.join(projectDirectory, configFile);
+  if (!existsSync(base)) return [];
+  const directory = path.dirname(base);
+  const files = [base];
+  for (const name of layerFileNames(path.basename(base), environment)) {
+    const candidate = path.join(directory, name);
+    if (existsSync(candidate) && !files.includes(candidate)) files.push(candidate);
+  }
+  return files;
+}
+
+export function mergeConfig(base, overlay) {
+  if (!isObject(base) || !isObject(overlay)) return overlay;
+  const result = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value === null) {
+      delete result[key];
+      continue;
+    }
+    if (isObject(result[key]) && isObject(value)) {
+      result[key] = mergeConfig(result[key], value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+function normalizeWindow(window, fallbackTitle) {
+  const value = isObject(window) ? { ...window } : {};
+  const title = value.title ?? fallbackTitle;
+  const width = value.width ?? value.size?.width ?? 800;
+  const height = value.height ?? value.size?.height ?? 600;
+  return {
+    ...value,
+    label: value.label ?? "main",
+    title,
+    width,
+    height,
+    minimumSize: value.minimumSize ?? { width: 0, height: 0 },
+    maximumSize: value.maximumSize ?? { width: 0, height: 0 },
+    resizable: value.resizable ?? true,
+    maximized: value.maximized ?? false,
+    fullscreen: value.fullscreen ?? false,
+    alwaysOnTop: value.alwaysOnTop ?? false,
+    decorations: value.decorations ?? true,
+    transparent: value.transparent ?? false,
+    visible: value.visible ?? true,
+    center: value.center ?? true,
+    devtools: value.devtools ?? false,
+    theme: value.theme ?? "automatic"
+  };
+}
+
+export function normalizeConfig(raw) {
+  const config = isObject(raw) ? structuredClone(raw) : {};
+  config.package = isObject(config.package) ? config.package : {};
+  config.app = isObject(config.app) ? config.app : {};
+  config.build = isObject(config.build) ? config.build : {};
+  config.bundle = isObject(config.bundle) ? config.bundle : {};
+  config.security = isObject(config.security) ? config.security : {};
+  config.plugins = isObject(config.plugins) ? config.plugins : {};
+
+  if (!config.app.productName) config.app.productName = config.package.productName ?? "";
+  if (!config.app.version) config.app.version = config.package.version ?? "";
+  if (!config.app.mainBinaryName) config.app.mainBinaryName = config.app.productName;
+
+  const fallbackTitle = config.app.productName || "flare-app";
+  const windows = Array.isArray(config.windows) && config.windows.length > 0 ? config.windows : [{}];
+  config.windows = windows.map((window) => normalizeWindow(window, fallbackTitle));
+
+  return config;
+}
+
+export function validateConfig(config) {
+  if (!isObject(config)) return "configuration root must be an object";
+  const identifier = config.app?.identifier;
+  if (!identifier || typeof identifier !== "string") return "app.identifier must not be empty";
+  if (!identifier.includes(".")) return "app.identifier must contain at least one dot";
+  const version = config.app?.version;
+  if (!version || !SEMVER.test(version)) return `app.version '${version}' is not a valid semver version`;
+  if (!Array.isArray(config.windows) || config.windows.length === 0) return "at least one window must be configured";
+
+  const labels = [];
+  for (const window of config.windows) {
+    if (!window.label) return "window label must not be empty";
+    if (!(window.width > 0) || !(window.height > 0)) return `window '${window.label}' has an invalid size`;
+    if (labels.includes(window.label)) return `duplicate window label '${window.label}'`;
+    labels.push(window.label);
+  }
+
+  return "";
+}
+
+export function parseConfig(text, source = DEFAULT_CONFIG_FILE) {
+  let document;
+  try {
+    document = JSON.parse(text);
+  } catch (error) {
+    throw new FlareError(`failed to parse '${source}': ${error.message}`);
+  }
+  if (!isObject(document)) throw new FlareError(`configuration root must be an object in '${source}'`);
+  return document;
+}
+
+export function loadProject({ projectDirectory = ".", configFile = DEFAULT_CONFIG_FILE, environment = "" } = {}) {
+  const directory = path.resolve(projectDirectory);
+  const files = resolveConfigFiles(directory, { configFile, environment });
+  if (files.length === 0) {
+    throw new FlareError(`no configuration file found for '${path.resolve(directory, configFile)}'`);
+  }
+
+  let merged = {};
+  for (const file of files) {
+    merged = mergeConfig(merged, parseConfig(readFileSync(file, "utf8"), file));
+  }
+
+  const config = normalizeConfig(merged);
+  const validation = validateConfig(config);
+  if (validation) throw new FlareError(`${validation} (${files[0]})`);
+
+  return { config, files, directory, configPath: files[0] };
+}
+
+export function mainWindow(config) {
+  return config.windows?.[0] ?? normalizeWindow({}, config.app?.productName);
+}
+
+export function productName(config) {
+  return config.app?.productName || config.package?.productName || "flare-app";
+}
+
+export function binaryName(config) {
+  return config.app?.mainBinaryName || productName(config);
+}
+
+export function frontendDirectory(projectDirectory, config) {
+  return path.resolve(projectDirectory, config.build?.frontendDist || "frontend");
+}

package/src/schema.js

@@ -0,0 +1,2 @@
+export const SCHEMA_URL =
+  "https://raw.githubusercontent.com/flare-desktop/flare/main/schemas/flare.config.schema.json";