@paroicms/site-generator-plugin 0.1.0

package/gen-backend/dist/generator/site-generator/document-template-creator.js

@@ -0,0 +1,329 @@
+import { camelToKebabCase } from "../lib/utils.js";
+import { templateOfDocumentBreadcrumb } from "./common-template-creator.js";
+import { createIdKeyProvider } from "./id-key-provider.js";
+import { getJtPartType, getJtRoutingDocumentType, hasTemporalChildren, } from "./jt-site-schema-helpers.js";
+import { getPredefinedDataType, indent, localizedLabelTemplate } from "./template-helpers.js";
+export function templateOfDocumentType(ctx, documentType) {
+    const childrenTemplate = templateOfDocumentChildren(ctx, documentType, createIdKeyProvider());
+    const featuredImageTemplate = documentType.withFeaturedImage
+        ? templateOfPicture({
+            imageKey: "doc.featuredImage",
+        })
+        : undefined;
+    const titleFieldsTemplate = templateOfTitleAndFields(ctx, documentType);
+    const listTemplates = documentType.lists?.map((list) => templateOfList(ctx, list, { listKey: `doc.list.${list.listName}`, nested: false })) ?? [];
+    const specialTemplate = templateOfSpecialDocument(ctx, documentType);
+    ctx.addLiquidFile("partials", "breadcrumb.liquid", templateOfDocumentBreadcrumb(), {
+        skipIfExists: true,
+    });
+    const blocks = [
+        `{% render "partials/breadcrumb" doc: doc site: site %}`,
+        featuredImageTemplate,
+        titleFieldsTemplate,
+        childrenTemplate,
+        specialTemplate,
+        ...listTemplates,
+    ].filter(Boolean);
+    return `{% layout "layouts/main-layout.liquid" doc: doc site: site %}
+{% block %}
+${blocks.map((block) => indent(block, 1)).join("\n\n")}
+{% endblock %}`;
+}
+function templateOfTitleAndFields(ctx, documentType) {
+    const blocks1 = ["<h1>{{ doc.title }}</h1>"];
+    const fieldsTemplate = templateOfFields(ctx, documentType.fields, { parentKey: "doc.field" });
+    if (fieldsTemplate) {
+        blocks1.push(fieldsTemplate);
+    }
+    const textBlock = `<div class="TextWidth">
+  ${indent(blocks1.join("\n"), 1, { skipFirst: true })}
+</div>`;
+    const siblingsTemplate = documentType.documentKind === "regular" && templateOfSiblingLinks(ctx);
+    const blocks2 = [textBlock, siblingsTemplate].filter(Boolean);
+    return `<div class="_bg2">
+  <div class="Container">
+    <div class="Page">
+      ${indent(blocks2.join("\n"), 3, { skipFirst: true })}
+    </div>
+  </div>
+</div>`;
+}
+function templateOfSpecialDocument(ctx, documentType) {
+    const { addLiquidFile } = ctx;
+    if (documentType.typeName === "search" || documentType.typeName === "searchPage") {
+        addLiquidFile("partials", "result-item.public.liquid", templateOfDocumentTile("doc"));
+        return `<div
+  class="Container"
+  data-effect="searchForm"
+  data-template="result-item"
+  data-limit="10"></div>`;
+    }
+    if (documentType.typeName === "contact" || documentType.typeName === "contactPage") {
+        return `<div class="Container">
+  <div class="TextWidth Pt">
+    <div
+      data-effect="contactForm"
+      data-recaptcha-key="{{ site.recaptchaKey }}"
+      data-home-url="{{ site.home.url }}"></div>
+  </div>
+</div>`;
+    }
+}
+function templateOfDocumentChildren(ctx, parentType, parentIdKeyProvider) {
+    const routingBlocks = templateOfRoutingChildren(ctx, parentType, parentIdKeyProvider);
+    const regularBlocks = parentType.documentKind === "routing" &&
+        parentType.regularChildren &&
+        templateOfRegularDocumentTiles(ctx, parentType, parentIdKeyProvider, {
+            mode: "all",
+        });
+    return [routingBlocks, regularBlocks].filter(Boolean).join("\n\n") || undefined;
+}
+function templateOfRoutingChildren(ctx, parentType, parentIdKeyProvider) {
+    const { siteSchema } = ctx;
+    const routingBlocks = (parentType.routingChildren ?? [])
+        .map((childName) => {
+        const child = getJtRoutingDocumentType(siteSchema, childName);
+        if (child.redirectTo) {
+            return templateOfDocumentChildren(ctx, child, parentIdKeyProvider.createForRoutingChild(childName));
+        }
+        return templateOfRoutingChild(ctx, child, parentIdKeyProvider);
+    })
+        .filter(Boolean);
+    if (routingBlocks.length === 0)
+        return;
+    return `<div class="Container">
+  ${indent(routingBlocks.join("\n\n"), 1, { skipFirst: true })}
+</div>`;
+}
+function templateOfRoutingChild(ctx, child, parentIdKeyProvider) {
+    const { siteSchema } = ctx;
+    const { typeName, regularChildrenSorting } = child;
+    const variableName = `${typeName}Doc`;
+    const idKeyProvider = parentIdKeyProvider.createForRoutingChild(typeName);
+    const idKey = idKeyProvider.idKey;
+    if (!hasTemporalChildren(siteSchema, child) || regularChildrenSorting !== "publishDate desc") {
+        const buttonTemplate = `{% getDoc ${variableName} id: ${idKey} %}
+<a class="Button" href="{{ ${variableName}.url }}">{{ ${variableName}.title }}</a>`;
+        return buttonTemplate;
+    }
+    const tilesTemplate = templateOfRegularDocumentTiles(ctx, child, idKeyProvider, {
+        mode: "sampleOnly",
+    });
+    return `{% getDoc ${variableName} id: ${idKey} %}
+<div class="Pt">
+  <h2>
+    <a class="TextLink" href="{{ ${variableName}.url }}">{{ ${variableName}.title }}</a>
+  </h2>
+  ${indent(tilesTemplate, 1, { skipFirst: true })}
+</div>`;
+}
+function templateOfRegularDocumentTiles(ctx, parentType, parentIdKeyProvider, { mode }) {
+    const { siteSchema, addLiquidFile } = ctx;
+    const { typeName: parentTypeName } = parentType;
+    const childrenVariableName = `${parentTypeName}Children`;
+    const childVariableName = `${parentTypeName}Child`;
+    const idKey = parentIdKeyProvider.idKey;
+    if (mode === "sampleOnly") {
+        return `{% getDocs ${childrenVariableName} parentId: ${idKey} limit: 4 %}
+<div class="List">
+  {% for ${childVariableName} in ${childrenVariableName} %}
+    ${indent(templateOfDocumentTile(childVariableName), 2, { skipFirst: true })}
+  {% endfor %}
+</div>`;
+    }
+    if (!hasTemporalChildren(siteSchema, parentType)) {
+        return `{% getDocs ${childrenVariableName} parentId: ${idKey} %}
+  <div class="Container List Pt Pb">
+  {% for ${childVariableName} in ${childrenVariableName} %}
+    ${indent(templateOfDocumentTile(childVariableName), 2, { skipFirst: true })}
+  {% endfor %}
+</div>`;
+    }
+    const tileTemplateName = `${camelToKebabCase(parentTypeName)}-tile`;
+    addLiquidFile("partials", `${tileTemplateName}.public.liquid`, templateOfDocumentTile("doc"));
+    return `{% getPaginatedDocs ${childrenVariableName} parentId: ${idKey} pageSize: 10 %}
+<div class="Container">
+  <div
+    class="Page List"
+    data-effect="infiniteLoading"
+    data-parent-id="{{ ${idKey} }}"
+    data-start="{{ ${childrenVariableName}.pageSize }}"
+    data-limit="{{ ${childrenVariableName}.pageSize }}"
+    data-total="{{ ${childrenVariableName}.total }}"
+    data-template="${tileTemplateName}">
+    {% for ${childrenVariableName} in ${childrenVariableName}.items %}
+      {% render "partials/${tileTemplateName}.public.liquid" doc: ${childrenVariableName} %}
+    {% endfor %}
+  </div>
+</div>`;
+}
+function templateOfFields(ctx, fields, { parentKey }) {
+    if (!fields || fields.length === 0)
+        return;
+    const fieldTemplates = fields.map((fieldOrName) => templateOfField(ctx, fieldOrName, parentKey));
+    return fieldTemplates.join("\n");
+}
+function templateOfField(ctx, fieldOrName, parentKey) {
+    const fieldName = typeof fieldOrName === "string" ? fieldOrName : fieldOrName.name;
+    const dataType = typeof fieldOrName === "string" ? getPredefinedDataType(ctx, fieldName) : fieldOrName.dataType;
+    if (dataType === "html" || dataType === "quillDelta") {
+        return `<div class="Field Text">{{ ${parentKey}.${fieldName} | raw }}</div>`;
+    }
+    if (dataType === "date") {
+        return `<div class="Field">{{ ${parentKey}.${fieldName} | formatDate: "short" }}</div>`;
+    }
+    if (dataType === "dateTime") {
+        return `<div class="Field">{{ ${parentKey}.${fieldName} | formatDate: "long" }}</div>`;
+    }
+    if (dataType === "json") {
+        return `<div class="Field">{{ ${parentKey}.${fieldName} | json }}</div>`;
+    }
+    if (dataType === "gallery") {
+        return `<div class="Field">
+  {% for media in ${parentKey}.${fieldName} %}
+    {% useImage im uid: media.uid size: "150x150" %}
+    <img
+      class="Field-img"
+      src="{{ im.url }}"
+      width="{{ im.width }}"
+      height="{{ im.height }}"
+      loading="lazy"
+      alt=""
+      data-zoom-src="{{ media.uid | imageZoomUrl }}">
+  {% endfor %}
+</div>`;
+    }
+    if (dataType === "media") {
+        const mediaUidKey = `${parentKey}.${fieldName}.uid`;
+        return `{% useImage im uid:${mediaUidKey} size: "x250x" %}
+<div class="Field">
+  <img
+    class="Field-img"
+    src="{{ im.url }}"
+    width="{{ im.width }}"
+    height="{{ im.height }}"
+    loading="lazy"
+    alt=""
+    data-zoom-src="{{ ${mediaUidKey} | imageZoomUrl }}">>
+</div>`;
+    }
+    if (fieldName === "title") {
+        return `<h2>{{ ${parentKey}.${fieldName} }}</h2>`;
+    }
+    return `<div class="Field">{{ ${parentKey}.${fieldName} }}</div>`;
+}
+function templateOfPicture({ imageKey }) {
+    return `{% if ${imageKey} %}
+  {% useImage smallIm uid: ${imageKey}.uid size: "360x48" %}
+  {% useImage largeIm uid: ${imageKey}.uid size: "1200x160" %}
+  <div class="Container">
+    <picture class="Hero">
+      <source
+        srcset="{{ largeIm.url }}"
+        width="{{ largeIm.width }}"
+        height="{{ largeIm.height }}"
+        media="(min-width: 360px)">
+      <img
+        src="{{ smallIm.url }}"
+        width="{{ smallIm.width }}"
+        height="{{ smallIm.height }}"
+        loading="lazy"
+        alt="">
+    </picture>
+  </div>
+{% endif %}`;
+}
+function templateOfList(ctx, list, { listKey, nested }) {
+    const { siteSchema, addLiquidFile, hasLiquidFile } = ctx;
+    if (list.parts.length === 0)
+        return;
+    const partTemplates = list.parts
+        .map((partName, index) => {
+        const partType = getJtPartType(siteSchema, partName);
+        const partTemplateName = `${camelToKebabCase(partType.typeName)}-part`;
+        if (!hasLiquidFile("partials", `${partTemplateName}.liquid`)) {
+            const partTemplate = templateOfPart(ctx, partType, "part");
+            addLiquidFile("partials", `${partTemplateName}.liquid`, partTemplate, {
+                skipIfExists: true,
+            });
+        }
+        const ifOrElsif = index === 0 ? "if" : "elsif";
+        return `{% ${ifOrElsif} part.type == "${partType.typeName}" %}
+  {% render "partials/${partTemplateName}.liquid" part: part %}`;
+    })
+        .filter(Boolean);
+    partTemplates.push("{% endif %}");
+    if (nested) {
+        return `{% if ${listKey} %}
+  <div class="Indent">
+    {% for part in ${listKey} %}
+      ${indent(partTemplates.join("\n"), 3, { skipFirst: true })}
+    {% endfor %}
+  </div>
+{% endif %}`;
+    }
+    return `{% if ${listKey} %}
+  <div class="_bg2">
+    <div class="Container Pb">
+      {% for part in ${listKey} %}
+        ${indent(partTemplates.join("\n"), 4, { skipFirst: true })}
+      {% endfor %}
+    </div>
+  </div>
+{% endif %}`;
+}
+function templateOfPart(ctx, part, partKey) {
+    const templates = [
+        templateOfFields(ctx, part.fields, { parentKey: `${partKey}.field` }),
+        part.list
+            ? templateOfList(ctx, part.list, {
+                listKey: `${partKey}.parts`,
+                nested: true,
+            })
+            : undefined,
+    ].filter(Boolean);
+    return `<section class="TextWidth">
+  ${indent(templates.join("\n\n"), 1, { skipFirst: true })}
+</section>`;
+}
+function templateOfSiblingLinks(ctx) {
+    const previousLabelTemplate = localizedLabelTemplate(ctx, {
+        en: "Previous",
+        fr: "Précédent",
+    });
+    const nextLabelTemplate = localizedLabelTemplate(ctx, {
+        en: "Next",
+        fr: "Suivant",
+    });
+    return `<div class="Row spaceBetween">
+  {% if doc.siblings.previous %}
+    <a href="{{ doc.siblings.previous.url }}" title="{{ doc.siblings.previous.title }}">← ${previousLabelTemplate}</a>
+  {% else %}
+    <span></span>
+  {% endif %}
+  {% if doc.siblings.next %}
+    <a href="{{ doc.siblings.next.url }}" title="{{ doc.siblings.next.title }}">${nextLabelTemplate} →</a>
+  {% endif %}
+</div>`;
+}
+function templateOfDocumentTile(docVariableName) {
+    return `<a href="{{ ${docVariableName}.url }}">
+  <article>
+    {% if ${docVariableName}.defaultImage %}
+      <div>
+        {% useImage im uid: ${docVariableName}.defaultImage.uid size: "120x120" %}
+        <img
+          src="{{ im.url }}"
+          width="{{ im.width }}"
+          height="{{ im.height }}"
+          loading="lazy"
+          alt="">
+      </div>
+    {% endif %}
+    <div>
+      <h3>{{ ${docVariableName}.title }}</h3>
+      <p>{{ ${docVariableName}.excerpt | makeExcerpt: 40 }}</p>
+    </div>
+  </article>
+</a>`;
+}

package/gen-backend/dist/generator/site-generator/id-key-provider.js

@@ -0,0 +1,14 @@
+export function createIdKeyProvider() {
+    return {
+        idKey: "doc.id",
+        getChildRoutingIdKey: (typeName) => `doc.routingIds.${typeName}.id`,
+        createForRoutingChild: (routingTypeName) => createChildIdKeyProvider(`doc.routingIds.${routingTypeName}`),
+    };
+}
+function createChildIdKeyProvider(key) {
+    return {
+        idKey: `${key}.id`,
+        getChildRoutingIdKey: (typeName) => `${key}.${typeName}.id`,
+        createForRoutingChild: (typeName) => createChildIdKeyProvider(`${key}.${typeName}`),
+    };
+}

package/gen-backend/dist/generator/site-generator/jt-site-schema-helpers.js

@@ -0,0 +1,55 @@
+export function getJtRoutingDocumentType(siteSchema, typeName) {
+    const nodeType = siteSchema.nodeTypes?.find((nodeType) => nodeType.typeName === typeName);
+    if (!nodeType)
+        throw new Error(`Node type not found: "${typeName}"`);
+    if (nodeType.kind !== "document" || nodeType.documentKind !== "routing") {
+        throw new Error(`Invalid routing document: "${typeName}"`);
+    }
+    return nodeType;
+}
+export function getJtRegularDocumentType(siteSchema, typeName) {
+    const nodeType = siteSchema.nodeTypes?.find((nodeType) => nodeType.typeName === typeName);
+    if (!nodeType)
+        throw new Error(`Node type not found: "${typeName}"`);
+    if (nodeType.kind !== "document" || nodeType.documentKind !== "regular") {
+        throw new Error(`Invalid regular document: "${typeName}"`);
+    }
+    return nodeType;
+}
+export function getJtPartType(siteSchema, typeName) {
+    const nodeType = siteSchema.nodeTypes?.find((nodeType) => nodeType.typeName === typeName);
+    if (!nodeType)
+        throw new Error(`Node type not found: "${typeName}"`);
+    if (nodeType.kind !== "part")
+        throw new Error(`Invalid part type: "${typeName}"`);
+    return nodeType;
+}
+export function hasTemporalChildren(siteSchema, documentType) {
+    return (documentType.regularChildren?.some((childName) => {
+        const child = getJtRegularDocumentType(siteSchema, childName);
+        return child.route === ":yyyy/:mm/:dd/:relativeId-:slug";
+    }) ?? false);
+}
+export function getJtHomeType(siteSchema) {
+    const homeType = siteSchema.nodeTypes?.find((type) => type.typeName === "home");
+    if (!homeType)
+        throw new Error("Home type not found in site schema");
+    if (homeType.kind !== "document" || homeType.documentKind !== "routing") {
+        throw new Error("Invalid home type in site schema");
+    }
+    return homeType;
+}
+export function getJtSiteType(siteSchema) {
+    const siteType = siteSchema.nodeTypes?.find((type) => type.kind === "site");
+    if (!siteType)
+        throw new Error("Site type not found");
+    return siteType;
+}
+export function isMultilingual(siteSchema) {
+    return siteSchema.languages.length > 1;
+}
+export function getFirstSiteLanguage(siteSchema) {
+    if (siteSchema.languages.length === 0)
+        throw new Error("Missing language in site schema");
+    return siteSchema.languages[0];
+}

package/gen-backend/dist/generator/site-generator/site-generator.js

@@ -0,0 +1,75 @@
+import { generateSlug } from "@paroicms/public-anywhere-lib";
+import { randomUUID } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fillSiteWithFakeContent } from "../fake-content-generator.ts/create-database-with-fake-content.js";
+import { createTheme } from "./theme-creator.js";
+export async function generateSite(ctx, input) {
+    const { service, logger, pluginConf: { packName }, } = ctx;
+    const { generatedSchema: { l10n, siteSchema, siteTitle }, withFakeContent, } = input;
+    const siteId = randomUUID();
+    logger.info(`Generating site: ${siteId}…`);
+    const packConf = service.connector.getSitePackConf(packName);
+    const { sitesDir } = packConf;
+    if (!sitesDir) {
+        throw new Error(`Site-generator plugin can generate sites only for pack with "sitesDir", but pack "${packName}" doesn't have it`);
+    }
+    const siteDir = join(sitesDir, siteId);
+    await mkdir(siteDir);
+    await writeFile(join(siteDir, "site-schema.json"), JSON.stringify(siteSchema, null, 2), "utf-8");
+    for (const [language, l10nData] of Object.entries(l10n)) {
+        await writeFile(join(siteDir, `site-schema.l10n.${language}.json`), JSON.stringify(l10nData, null, 2), "utf-8");
+    }
+    await writeFile(join(siteDir, "package.json"), JSON.stringify(getPackageJsonContent({
+        siteTitle: siteTitle.en ?? Object.values(siteTitle)[0] ?? "new-website",
+    }), null, 2), "utf-8");
+    await createTheme(ctx, siteDir, siteSchema);
+    const siteConf = await service.registerNewSite({
+        packName,
+        siteDir,
+        domain: siteId,
+        version: "0.0.0",
+    });
+    if (withFakeContent) {
+        await fillSiteWithFakeContent(ctx, { siteConf, siteId, siteTitle });
+    }
+    const { siteUrl } = siteConf;
+    return {
+        siteId,
+        url: siteUrl,
+        boUrl: `${siteUrl}/adm`,
+    };
+}
+function getPackageJsonContent(options) {
+    return {
+        name: generateSlug(options.siteTitle),
+        version: "0.0.0",
+        private: true,
+        type: "module",
+        scripts: {
+            start: "paroicms | npm run _pino-pretty",
+            "start:dev": "nodemon --watch 'site-schema*.json' --watch config.json",
+            clear: "rimraf theme/assets/css/*",
+            build: "npm run scss",
+            dev: "concurrently -n 'node,scss' -c 'yellow.bold,magenta.bold' 'npm run start:dev' 'npm run scss:watch'",
+            scss: "npm run _scss -- --no-source-map --style=compressed",
+            "scss:watch": "npm run _scss && npm run _scss -- --watch",
+            _scss: "sass theme/assets/scss/theme.scss theme/assets/css/theme.css",
+            "_pino-pretty": "pino-pretty -U false -x 'stats:25' -X 'stats:grey' -t 'yyyy-mm-dd HH:MM:ss.l' -i 'hostname,pid,fqdn'",
+        },
+        dependencies: {
+            "@paroicms/contact-form-plugin": "0.18.0",
+            "@paroicms/content-loading-plugin": "0.11.0",
+            "@paroicms/public-menu-plugin": "0.8.0",
+            "@paroicms/server": "*",
+            "@paroicms/quill-editor-plugin": "1.27.0",
+        },
+        devDependencies: {
+            concurrently: "~9.1.2",
+            nodemon: "~3.1.9",
+            "pino-pretty": "~13.0.0",
+            rimraf: "~6.0.1",
+            sass: "~1.83.4",
+        },
+    };
+}

package/gen-backend/dist/generator/site-generator/template-creator-types.js

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

package/gen-backend/dist/generator/site-generator/template-helpers.js

@@ -0,0 +1,26 @@
+import { getFirstSiteLanguage, isMultilingual } from "./jt-site-schema-helpers.js";
+export function indent(template, level, { skipFirst = false } = {}) {
+    const indentStr = "  ".repeat(level);
+    if (skipFirst) {
+        const lines = template.split("\n");
+        return lines.map((line, index) => (index === 0 ? line : indentStr + line)).join("\n");
+    }
+    // For firstLine true, indent all lines.
+    return template.replace(/^/gm, indentStr);
+}
+export function getPredefinedDataType(ctx, fieldName) {
+    const predefinedField = ctx.predefinedFields.get(fieldName);
+    if (!predefinedField)
+        return "string";
+    return predefinedField.dataType;
+}
+export function localizedLabelTemplate(ctx, label) {
+    const { siteSchema, setLocalizedLabel: appendLocalizedLabel } = ctx;
+    const firstLanguage = getFirstSiteLanguage(siteSchema);
+    const defaultLabel = firstLanguage in label ? label[firstLanguage] : label.en;
+    if (!isMultilingual(siteSchema)) {
+        return defaultLabel;
+    }
+    appendLocalizedLabel(label);
+    return `{{ "${defaultLabel.replaceAll('"', '\\"')}" | t }}`;
+}

package/gen-backend/dist/generator/site-generator/theme-creator.js

@@ -0,0 +1,180 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getPredefinedFields } from "../lib/create-prompt.js";
+import { camelToKebabCase } from "../lib/utils.js";
+import { templateOfSiteFooter, templateOfSiteHeader } from "./common-template-creator.js";
+import { templateOfDocumentType } from "./document-template-creator.js";
+import { isMultilingual } from "./jt-site-schema-helpers.js";
+import { getThemeCssContent } from "./theme-css.js";
+export async function createTheme(ctx, siteDir, siteSchema) {
+    const themeContext = createThemeCreatorContext(siteSchema);
+    for (const nodeType of siteSchema.nodeTypes ?? []) {
+        if (nodeType.kind === "site")
+            continue;
+        if (nodeType.kind === "part")
+            continue;
+        themeContext.addLiquidFile("root", `${camelToKebabCase(nodeType.typeName)}.liquid`, templateOfDocumentType(themeContext, nodeType));
+    }
+    themeContext.addFile("theme.json", getThemeJsonContent());
+    themeContext.addFile("assets/scss/theme.scss", getThemeCssContent());
+    themeContext.addFile("assets/css/theme.css", getThemeCssContent());
+    themeContext.addLiquidFile("layouts", "main-layout.liquid", templateOfLayout(themeContext));
+    themeContext.addLiquidFile("root", "404.liquid", templateOf404(themeContext));
+    if (isMultilingual(siteSchema)) {
+        themeContext.addLiquidFile("root", "index.liquid", templateOfIndex());
+    }
+    const themeDir = join(siteDir, "theme");
+    await mkdir(themeDir);
+    const { files, issues } = themeContext.toFiles();
+    for (const file of files) {
+        const filePath = join(themeDir, file.path);
+        const dirPath = dirname(filePath);
+        await ensureDirectory(dirPath, { recursive: true });
+        await writeFile(filePath, file.content, "utf-8");
+    }
+    if (issues) {
+        ctx.logger.warn(`Issues in "${siteDir}":`, issues);
+    }
+}
+function createThemeCreatorContext(siteSchema) {
+    const languages = siteSchema.languages ?? [];
+    const liquidFiles = new Map();
+    const localeFiles = new Map();
+    const otherFiles = new Map();
+    const issues = [];
+    return {
+        siteSchema,
+        predefinedFields: new Map(getPredefinedFields().map((f) => [f.fieldName, f])),
+        setLocalizedLabel(label) {
+            for (const language of languages) {
+                const value = label[language];
+                if (!value)
+                    continue;
+                let f = localeFiles.get(language);
+                if (!f) {
+                    f = {};
+                    localeFiles.set(language, f);
+                }
+                f[language] = value;
+            }
+        },
+        hasLiquidFile(directory, fileName) {
+            const path = directory === "root" ? `templates/${fileName}` : `templates/${directory}/${fileName}`;
+            return liquidFiles.has(path);
+        },
+        addLiquidFile(directory, fileName, content, { skipIfExists = false } = {}) {
+            const path = directory === "root" ? `templates/${fileName}` : `templates/${directory}/${fileName}`;
+            if (liquidFiles.has(path)) {
+                if (skipIfExists)
+                    return;
+                issues.push(`Liquid file already exists, overwrite: "${path}"`);
+            }
+            liquidFiles.set(path, content);
+        },
+        addFile(path, content) {
+            if (otherFiles.has(path))
+                throw new Error(`File already exists: "${path}"`);
+            otherFiles.set(path, content);
+        },
+        toFiles() {
+            const files = [
+                ...Array.from(liquidFiles.entries()).map(([path, content]) => ({ path, content })),
+                ...Array.from(localeFiles.entries()).map(([language, content]) => ({
+                    path: `locales/${language}.json`,
+                    content: JSON.stringify(content, null, 2),
+                })),
+                ...Array.from(otherFiles.entries()).map(([path, content]) => ({ path, content })),
+            ];
+            files.sort((a, b) => a.path.localeCompare(b.path));
+            return { files, issues: issues.length > 0 ? issues : undefined };
+        },
+    };
+}
+// function getDefaultLiquidContent() {
+//   return `{% layout "layouts/main-layout.liquid" doc: doc site: site %}
+// {% block %}
+// <div class="Container">
+//   <div class="Page">
+//     {{ doc | info }}
+//   </div>
+// </div>
+// {% endblock %}`;
+// }
+function templateOf404(ctx) {
+    const { siteSchema } = ctx;
+    const rawParam = isMultilingual(siteSchema) ? " raw: true" : "";
+    return `{% layout "layouts/main-layout.liquid" doc: doc site: site${rawParam} %}
+{% block %}
+<div class="Container">
+  <div class="Page">
+    <h1>404</h1>
+    <p>This page doesn't exist. Please <a href='/'>return to home page</a>.</p>
+  </div>
+</div>
+{% endblock %}`;
+}
+function templateOfIndex() {
+    return `{% layout "layouts/main-layout.liquid" doc: doc site: site raw: true %}
+{% block %}
+<div class="Container">
+  <div class="Page">
+    {% for translation in doc.translations %}
+      <a href="{{ translation.url }}">{{ translation.languageLabel }}</a>
+    {% endfor %}
+  </div>
+</div>
+{% endblock %}`;
+}
+function templateOfLayout(ctx) {
+    const { siteSchema } = ctx;
+    const multilingual = isMultilingual(siteSchema);
+    ctx.addLiquidFile("partials", "site-header.liquid", templateOfSiteHeader(ctx));
+    ctx.addLiquidFile("partials", "site-footer.liquid", templateOfSiteFooter(ctx));
+    const renderHeader = `{% render "partials/site-header" doc: doc site: site %}`;
+    const headerTemplate = multilingual
+        ? `{% unless raw %}
+  ${renderHeader}
+{% endunless %}`
+        : renderHeader;
+    const renderFooter = `{% render "partials/site-footer" doc: doc site: site %}`;
+    const footerTemplate = multilingual
+        ? `{% unless raw %}
+  ${renderFooter}
+{% endunless %}`
+        : renderFooter;
+    return `<!doctype html>
+<html lang="{{ doc.language }}">
+<head>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  {{ doc | headTags }}
+  <title>
+    {% if doc.type != "home" and doc.title %}
+      {{ doc.title }} -{% endif %}
+    {{ site.field.title }}</title>
+  <link rel="stylesheet" href="{{ site.assetsUrl }}/css/theme.css">
+</head>
+<body>
+  ${headerTemplate}
+
+  {% block -%}
+  {%- endblock %}
+
+  ${footerTemplate}
+</body>
+</html>`;
+}
+function getThemeJsonContent() {
+    return JSON.stringify({
+        fTextImages: ["700x", "x400x", "700x350"],
+        pixelRatio: 1.5,
+    }, null, 2);
+}
+async function ensureDirectory(dirPath, { recursive = false } = {}) {
+    try {
+        await mkdir(dirPath, { recursive });
+    }
+    catch (e) {
+        if (e.code !== "EEXIST")
+            throw e;
+    }
+}