@semi-solid/compiler 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 semi-solid contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-BDCUB2QP.js

@@ -0,0 +1,28 @@
+// src/cli/config.ts
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+async function loadConfig(root) {
+  const configPath = path.join(root, "semi-solid.config.ts");
+  if (fs.existsSync(configPath)) {
+    const mod = await import(pathToFileURL(configPath).href);
+    return mod.default;
+  }
+  const brandsDir = path.join(root, "src", "brands");
+  const brands = {};
+  if (fs.existsSync(brandsDir)) {
+    for (const brand of fs.readdirSync(brandsDir)) {
+      const i18nDir = path.join(brandsDir, brand, "i18n");
+      if (!fs.existsSync(i18nDir)) continue;
+      const locales = fs.readdirSync(i18nDir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+      if (locales.length > 0) {
+        brands[brand] = { locales };
+      }
+    }
+  }
+  return { brands };
+}
+
+export {
+  loadConfig
+};

package/dist/chunk-HSIWLJX2.js

@@ -0,0 +1,41 @@
+// src/i18n.ts
+import path from "path";
+import fs from "fs";
+var VIRTUAL_LOCALE_MODULE = "virtual:semi-solid/locale";
+var RESOLVED_VIRTUAL_ID = "\0" + VIRTUAL_LOCALE_MODULE;
+function resolveLocaleFiles(brand, locale, projectRoot, outDir, existsSync = fs.existsSync, readdirSync = (d) => fs.readdirSync(d)) {
+  const i18nDir = path.join(projectRoot, "src", "brands", brand, "i18n");
+  const localesOutDir = path.join(outDir, "locales");
+  if (!existsSync(i18nDir)) return [];
+  const files = readdirSync(i18nDir).filter((f) => f.endsWith(".json"));
+  return files.map((file) => {
+    const lang = file.replace(/\.json$/, "");
+    const destName = lang === locale ? `${locale}.default.json` : file;
+    return {
+      src: path.join(i18nDir, file),
+      dest: path.join(localesOutDir, destName)
+    };
+  });
+}
+function resolveActiveLocalePath(brand, locale, projectRoot, existsSync = fs.existsSync) {
+  const candidate = path.join(
+    projectRoot,
+    "src",
+    "brands",
+    brand,
+    "i18n",
+    `${locale}.json`
+  );
+  return existsSync(candidate) ? candidate : null;
+}
+var virtualLocaleIds = {
+  external: VIRTUAL_LOCALE_MODULE,
+  internal: RESOLVED_VIRTUAL_ID
+};
+
+export {
+  VIRTUAL_LOCALE_MODULE,
+  resolveLocaleFiles,
+  resolveActiveLocalePath,
+  virtualLocaleIds
+};

package/dist/chunk-X2A6LNIZ.js

@@ -0,0 +1,429 @@
+import {
+  resolveLocaleFiles
+} from "./chunk-HSIWLJX2.js";
+import {
+  loadConfig
+} from "./chunk-BDCUB2QP.js";
+
+// src/cli/index.ts
+import { defineCommand as defineCommand5, runMain as cittyRunMain } from "citty";
+
+// src/cli/commands/build.ts
+import { defineCommand } from "citty";
+
+// src/cli/vite-bridge.ts
+import { build } from "vite";
+async function runBuild(opts) {
+  process.env.BRAND = opts.brand;
+  process.env.LOCALE = opts.locale;
+  await build();
+}
+async function runWatchBuild(opts) {
+  process.env.BRAND = opts.brand;
+  process.env.LOCALE = opts.locale;
+  await build({ build: { watch: {} } });
+}
+
+// src/cli/commands/build.ts
+var buildCommand = defineCommand({
+  meta: {
+    name: "build",
+    description: "Build a single brand/locale combo"
+  },
+  args: {
+    brand: {
+      type: "string",
+      description: "Brand identifier (e.g. brand-a)",
+      required: true
+    },
+    locale: {
+      type: "string",
+      description: "Locale identifier (e.g. en)",
+      required: true
+    }
+  },
+  async run({ args }) {
+    console.log(`Building ${args.brand}/${args.locale}...`);
+    await runBuild({ brand: args.brand, locale: args.locale });
+    console.log(`Done: ${args.brand}/${args.locale}`);
+  }
+});
+
+// src/cli/commands/build-all.ts
+import { defineCommand as defineCommand2 } from "citty";
+var buildAllCommand = defineCommand2({
+  meta: {
+    name: "build-all",
+    description: "Build all brand/locale combos from config"
+  },
+  args: {
+    parallel: {
+      type: "boolean",
+      description: "Run builds in parallel",
+      default: false
+    },
+    concurrency: {
+      type: "string",
+      description: "Max parallel builds (requires --parallel)",
+      default: "3"
+    }
+  },
+  async run({ args }) {
+    const config = await loadConfig(process.cwd());
+    const pairs = [];
+    for (const [brand, brandConfig] of Object.entries(config.brands)) {
+      for (const locale of brandConfig.locales) {
+        pairs.push({ brand, locale });
+      }
+    }
+    if (pairs.length === 0) {
+      console.log("No brand/locale pairs found in config.");
+      return;
+    }
+    console.log(`Building ${pairs.length} combo(s)...`);
+    if (args.parallel) {
+      const concurrency = parseInt(args.concurrency, 10) || 3;
+      const queue = [...pairs];
+      const running = [];
+      while (queue.length > 0 || running.length > 0) {
+        while (running.length < concurrency && queue.length > 0) {
+          const pair = queue.shift();
+          const task = (async () => {
+            console.log(`  Building ${pair.brand}/${pair.locale}...`);
+            await runBuild(pair);
+            console.log(`  Done: ${pair.brand}/${pair.locale}`);
+          })();
+          running.push(task);
+        }
+        if (running.length > 0) {
+          await Promise.race(running);
+          for (let i = running.length - 1; i >= 0; i--) {
+            const settled = await Promise.race([
+              running[i].then(() => true),
+              Promise.resolve(false)
+            ]);
+            if (settled) running.splice(i, 1);
+          }
+        }
+      }
+    } else {
+      for (const pair of pairs) {
+        console.log(`  Building ${pair.brand}/${pair.locale}...`);
+        await runBuild(pair);
+        console.log(`  Done: ${pair.brand}/${pair.locale}`);
+      }
+    }
+    console.log(`All ${pairs.length} builds complete.`);
+  }
+});
+
+// src/cli/commands/dev.ts
+import { defineCommand as defineCommand3 } from "citty";
+import { spawn } from "child_process";
+var devCommand = defineCommand3({
+  meta: {
+    name: "dev",
+    description: "Watch build + Shopify theme dev"
+  },
+  args: {
+    brand: {
+      type: "string",
+      description: "Brand identifier (e.g. brand-a)",
+      required: true
+    },
+    locale: {
+      type: "string",
+      description: "Locale identifier (e.g. en)",
+      required: true
+    },
+    store: {
+      type: "string",
+      description: "Shopify store URL (overrides config)"
+    },
+    "no-shopify": {
+      type: "boolean",
+      description: "Skip Shopify CLI (watch-only mode)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const brand = args.brand;
+    const locale = args.locale;
+    const noShopify = args["no-shopify"];
+    console.log(`Starting dev for ${brand}/${locale}...`);
+    const watchPromise = runWatchBuild({ brand, locale });
+    if (!noShopify) {
+      const config = await loadConfig(process.cwd());
+      const brandConfig = config.brands[brand];
+      const store = args.store || brandConfig?.store;
+      if (!store) {
+        console.error(
+          `No store URL for brand "${brand}". Pass --store or set it in semi-solid.config.ts.`
+        );
+        process.exit(1);
+      }
+      const distPath = `./dist/${brand}/${locale}`;
+      const shopifyArgs = ["theme", "dev", "--path", distPath, "--store", store];
+      if (brandConfig?.storePassword) {
+        shopifyArgs.push("--store-password", brandConfig.storePassword);
+      }
+      console.log(`Starting Shopify CLI: shopify ${shopifyArgs.join(" ")}`);
+      const shopify = spawn("shopify", shopifyArgs, {
+        stdio: "inherit",
+        shell: true
+      });
+      shopify.on("error", (err) => {
+        console.error(`Shopify CLI error: ${err.message}`);
+      });
+      shopify.on("close", (code) => {
+        if (code !== 0) {
+          console.error(`Shopify CLI exited with code ${code}`);
+        }
+      });
+    }
+    await watchPromise;
+  }
+});
+
+// src/cli/commands/backfill.ts
+import { defineCommand as defineCommand4 } from "citty";
+import fs from "fs";
+import path from "path";
+var REQUIRED_THEME_FILES = {
+  "layout/theme.liquid": [
+    "<!DOCTYPE html>",
+    '<html lang="{{ request.locale.iso_code }}">',
+    "<head>",
+    '  <meta charset="utf-8">',
+    "  {{ content_for_header }}",
+    "</head>",
+    "<body>",
+    "  {{ content_for_layout }}",
+    "</body>",
+    "</html>",
+    ""
+  ].join("\n"),
+  "templates/gift_card.liquid": [
+    "<!DOCTYPE html>",
+    '<html lang="{{ request.locale.iso_code }}">',
+    "<head>",
+    '  <meta charset="utf-8">',
+    '  <meta name="viewport" content="width=device-width, initial-scale=1">',
+    "  <title>{{ 'gift_cards.issued.title' | t }} \u2014 {{ shop.name }}</title>",
+    "  {{ content_for_header }}",
+    "  {% render 'theme-assets' %}",
+    "</head>",
+    '<body class="gift-card-page">',
+    '  <header class="text-center py-8">',
+    '    <a href="{{ shop.url }}">',
+    "      <h1>{{ shop.name }}</h1>",
+    "    </a>",
+    "  </header>",
+    '  <main class="gift-card max-w-md mx-auto px-4 text-center">',
+    "    <h2>{{ 'gift_cards.issued.subtext' | t }}</h2>",
+    "    {% if gift_card.enabled %}",
+    '      <p class="gift-card__amount text-4xl font-bold my-4">{{ gift_card.initial_value | money }}</p>',
+    "      {% if gift_card.balance != gift_card.initial_value %}",
+    "        <p>{{ 'gift_cards.issued.remaining_html' | t: balance: gift_card.balance | money }}</p>",
+    "      {% endif %}",
+    '      <div class="gift-card__code my-6">',
+    '        <input type="text" value="{{ gift_card.code | format_code }}" class="text-center border rounded px-4 py-3 w-full text-lg tracking-widest" readonly onfocus="this.select();">',
+    "      </div>",
+    "      {% if gift_card.pass_url %}",
+    '        <a href="{{ gift_card.pass_url }}" class="inline-block mb-4">',
+    `          <img src="{{ 'gift-card/add-to-apple-wallet.svg' | shopify_asset_url }}" alt="{{ 'gift_cards.issued.add_to_apple_wallet' | t }}" width="120">`,
+    "        </a>",
+    "      {% endif %}",
+    `      <p class="text-sm text-gray-500">{{ 'gift_cards.issued.expiry_html' | t: expires: gift_card.expires_on | date: "%B %d, %Y" }}</p>`,
+    "    {% else %}",
+    "      <p>{{ 'gift_cards.issued.disabled' | t }}</p>",
+    "    {% endif %}",
+    `    <a href="{{ shop.url }}" class="inline-block mt-8 bg-primary text-white px-8 py-3 rounded">{{ 'gift_cards.issued.shop_link' | t }}</a>`,
+    "  </main>",
+    "</body>",
+    "</html>",
+    ""
+  ].join("\n"),
+  "config/settings_schema.json": JSON.stringify(
+    [
+      {
+        name: "theme_info",
+        theme_name: "Semi-Solid",
+        theme_version: "1.0.0",
+        theme_author: "Semi-Solid",
+        theme_documentation_url: "https://github.com/CarlR100/semi-solid",
+        theme_support_url: "https://github.com/CarlR100/semi-solid"
+      },
+      {
+        name: "Colors",
+        settings: [
+          { type: "color", id: "color_primary", label: "Primary", default: "#111827" },
+          { type: "color", id: "color_secondary", label: "Secondary", default: "#6b7280" },
+          { type: "color", id: "color_background", label: "Background", default: "#ffffff" },
+          { type: "color", id: "color_text", label: "Text", default: "#111827" }
+        ]
+      },
+      {
+        name: "Typography",
+        settings: [
+          { type: "font_picker", id: "heading_font", label: "Heading font", default: "assistant_n4" },
+          { type: "font_picker", id: "body_font", label: "Body font", default: "assistant_n4" }
+        ]
+      },
+      {
+        name: "Layout",
+        settings: [
+          { type: "range", id: "page_width", label: "Page width", default: 1200, min: 1e3, max: 1600, step: 100, unit: "px" }
+        ]
+      }
+    ],
+    null,
+    2
+  ) + "\n",
+  "config/settings_data.json": [
+    "// This file is auto-generated. Edit config/settings_schema.json for schema.",
+    '{ "current": {} }',
+    ""
+  ].join("\n")
+};
+var VALID_TARGETS = ["locales", "templates", "scaffold", "theme"];
+var backfillCommand = defineCommand4({
+  meta: {
+    name: "backfill",
+    description: "Targeted regeneration of specific outputs without a full Vite build"
+  },
+  args: {
+    brand: {
+      type: "string",
+      description: "Brand identifier (e.g. brand-a)",
+      required: true
+    },
+    locale: {
+      type: "string",
+      description: "Locale identifier (e.g. en)",
+      required: true
+    },
+    target: {
+      type: "string",
+      description: "Comma-separated targets: locales, templates, scaffold, theme",
+      required: true
+    }
+  },
+  async run({ args }) {
+    const { brand, locale } = args;
+    const root = process.cwd();
+    const outDir = path.resolve(root, "dist", brand, locale);
+    const targets = args.target.split(",").map((t) => t.trim());
+    for (const t of targets) {
+      if (!VALID_TARGETS.includes(t)) {
+        console.error(`Invalid target: "${t}". Valid targets: ${VALID_TARGETS.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    console.log(`Backfilling ${targets.join(", ")} for ${brand}/${locale}...`);
+    if (targets.includes("locales")) {
+      backfillLocales(brand, locale, root, outDir);
+    }
+    if (targets.includes("templates")) {
+      backfillTemplates(brand, root, outDir);
+    }
+    if (targets.includes("scaffold")) {
+      backfillScaffold(outDir);
+    }
+    if (targets.includes("theme")) {
+      backfillTheme(brand, root, outDir);
+    }
+    console.log("Backfill complete.");
+  }
+});
+function backfillLocales(brand, locale, root, outDir) {
+  const pairs = resolveLocaleFiles(brand, locale, root, outDir);
+  if (pairs.length === 0) {
+    console.log("  No locale files found.");
+    return;
+  }
+  for (const { src, dest } of pairs) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+    console.log(`  Copied ${path.basename(src)} \u2192 ${path.relative(root, dest)}`);
+  }
+}
+function backfillTemplates(brand, root, outDir) {
+  const baseDir = path.join(root, "src", "templates");
+  const brandDir = path.join(root, "src", "brands", brand, "templates");
+  const destDir = path.join(outDir, "templates");
+  const templateMap = /* @__PURE__ */ new Map();
+  for (const dir of [baseDir, brandDir]) {
+    if (!fs.existsSync(dir)) continue;
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.endsWith(".json")) continue;
+      templateMap.set(file, path.join(dir, file));
+    }
+  }
+  if (templateMap.size === 0) {
+    console.log("  No template files found.");
+    return;
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+  for (const [file, src] of templateMap) {
+    fs.copyFileSync(src, path.join(destDir, file));
+    console.log(`  Copied templates/${file}`);
+  }
+}
+function backfillScaffold(outDir) {
+  for (const [relPath, content] of Object.entries(REQUIRED_THEME_FILES)) {
+    const fullPath = path.join(outDir, relPath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content, "utf-8");
+    console.log(`  Wrote ${relPath}`);
+  }
+}
+function backfillTheme(brand, root, outDir) {
+  const baseThemeDir = path.join(root, "src", "theme");
+  const brandThemeDir = path.join(root, "src", "brands", brand, "theme");
+  let copied = 0;
+  for (const themeDir of [baseThemeDir, brandThemeDir]) {
+    if (!fs.existsSync(themeDir)) continue;
+    const copyDir = (dir, relBase) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const srcPath = path.join(dir, entry.name);
+        const relPath = path.join(relBase, entry.name);
+        if (entry.isDirectory()) {
+          copyDir(srcPath, relPath);
+        } else {
+          const destPath = path.join(outDir, relPath);
+          if (fs.existsSync(destPath)) continue;
+          fs.mkdirSync(path.dirname(destPath), { recursive: true });
+          fs.copyFileSync(srcPath, destPath);
+          console.log(`  Copied theme/${relPath}${themeDir === brandThemeDir ? ` (brand: ${brand})` : ""}`);
+          copied++;
+        }
+      }
+    };
+    copyDir(themeDir, "");
+  }
+  if (copied === 0) {
+    console.log("  No theme files to copy.");
+  }
+}
+
+// src/cli/index.ts
+var main = defineCommand5({
+  meta: {
+    name: "semi-solid",
+    description: "Semi-Solid CLI \u2014 build Shopify themes from SolidJS components"
+  },
+  subCommands: {
+    build: buildCommand,
+    "build-all": buildAllCommand,
+    dev: devCommand,
+    backfill: backfillCommand
+  }
+});
+function runMain() {
+  cittyRunMain(main);
+}
+
+export {
+  runMain
+};

package/dist/cli/bin.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli/bin.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  runMain
+} from "../chunk-X2A6LNIZ.js";
+import "../chunk-HSIWLJX2.js";
+import "../chunk-BDCUB2QP.js";
+
+// src/cli/bin.ts
+runMain();

package/dist/cli/config.d.ts

@@ -0,0 +1,17 @@
+interface BrandConfig {
+    locales: string[];
+    store?: string;
+    storePassword?: string;
+}
+interface SemiSolidConfig {
+    brands: Record<string, BrandConfig>;
+}
+/**
+ * Load the semi-solid config from the project root.
+ *
+ * Tries to import `semi-solid.config.ts` (via tsx runtime).
+ * Falls back to auto-discovery from `src/brands/* /i18n/*.json`.
+ */
+declare function loadConfig(root: string): Promise<SemiSolidConfig>;
+
+export { type BrandConfig, type SemiSolidConfig, loadConfig };

package/dist/cli/config.js

@@ -0,0 +1,6 @@
+import {
+  loadConfig
+} from "../chunk-BDCUB2QP.js";
+export {
+  loadConfig
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+declare function runMain(): void;
+
+export { runMain };

package/dist/cli/index.js

@@ -0,0 +1,8 @@
+import {
+  runMain
+} from "../chunk-X2A6LNIZ.js";
+import "../chunk-HSIWLJX2.js";
+import "../chunk-BDCUB2QP.js";
+export {
+  runMain
+};