@shevky/core 0.0.2 → 0.0.3

package/lib/project.js

@@ -0,0 +1,82 @@
+import { io as _io } from "@shevky/base";
+
+/** @typedef {import("../types/index.d.ts").ProjectPaths} ProjectPaths */
+
+export class Project {
+  /**
+   * @type {string}
+   */
+  #_baseDir;
+
+  /**
+   * @param {string} [baseDir="."]
+   */
+  constructor(baseDir = ".") {
+    this.#_baseDir = baseDir;
+  }
+
+  get rootDir() {
+    return _io.path.combine(this.#_baseDir);
+  }
+
+  get srcDir() {
+    return _io.path.combine(this.rootDir, "src");
+  }
+
+  get distDir() {
+    return _io.path.combine(this.rootDir, "dist");
+  }
+
+  get tmpDir() {
+    return _io.path.combine(this.rootDir, "tmp");
+  }
+
+  get contentDir() {
+    return _io.path.combine(this.srcDir, "content");
+  }
+
+  get layoutsDir() {
+    return _io.path.combine(this.srcDir, "layouts");
+  }
+
+  get componentsDir() {
+    return _io.path.combine(this.srcDir, "components");
+  }
+
+  get templatesDir() {
+    return _io.path.combine(this.srcDir, "templates");
+  }
+
+  get assetsDir() {
+    return _io.path.combine(this.srcDir, "assets");
+  }
+
+  get siteConfig() {
+    return _io.path.combine(this.srcDir, "site.json");
+  }
+
+  get i18nConfig() {
+    return _io.path.combine(this.srcDir, "i18n.json");
+  }
+
+  /**
+   * @returns {ProjectPaths}
+   */
+  toObject() {
+    return {
+      root: this.rootDir,
+      src: this.srcDir,
+      dist: this.distDir,
+      tmp: this.tmpDir,
+      content: this.contentDir,
+      layouts: this.layoutsDir,
+      components: this.componentsDir,
+      templates: this.templatesDir,
+      assets: this.assetsDir,
+      siteConfig: this.siteConfig,
+      i18nConfig: this.i18nConfig,
+    };
+  }
+}
+
+export default new Project();

package/lib/template.js

@@ -0,0 +1,50 @@
+export class Template {
+  /**
+   * @type {string}
+   */
+  #_key;
+
+  /**
+   * @type {string}
+   */
+  #_path;
+
+  /**
+   * @type {string}
+   */
+  #_content;
+
+  /**
+   * @type {string}
+   */
+  #_type;
+
+  /**
+   * @param {string} key
+   * @param {string} type
+   * @param {string} path
+   * @param {string} content
+   */
+  constructor(key, type, path, content) {
+    this.#_key = key;
+    this.#_type = type;
+    this.#_path = path;
+    this.#_content = content;
+  }
+
+  get key() {
+    return this.#_key;
+  }
+
+  get type() {
+    return this.#_type;
+  }
+
+  get path() {
+    return this.#_path;
+  }
+
+  get content() {
+    return this.#_content;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shevky/core",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "A minimal, dependency-light static site generator.",
   "type": "module",
   "main": "shevky.js",
@@ -9,7 +9,11 @@
   },
   "files": [
     "shevky.js",
+    "lib/",
+    "engines/",
+    "registries/",
     "scripts/",
+    "types/",
     "README.md",
     "LICENSE"
   ],

package/registries/contentRegistry.js

@@ -0,0 +1,286 @@
+import { io as _io } from "@shevky/base";
+import matter from "gray-matter";
+
+import { ContentFile } from "../lib/contentFile.js";
+import { ContentSummary } from "../lib/contentSummary.js";
+import { MetaEngine } from "../engines/metaEngine.js";
+
+export class ContentRegistry {
+  /**
+   * @type {ContentFile[]}
+   */
+  #_cache = [];
+  /** @type {import("../types/index.d.ts").CollectionsByLang | null} */
+  #_collectionsCache = null;
+  /** @type {ReturnType<ContentRegistry["buildFooterPolicies"]> | null} */
+  #_footerPoliciesCache = null;
+  /** @type {ReturnType<ContentRegistry["buildContentIndex"]> | null} */
+  #_contentIndexCache = null;
+  /** @type {MetaEngine} */
+  #_metaEngine;
+
+  /**
+   * @param {MetaEngine} metaEngine
+   */
+  constructor(metaEngine) {
+    this.#_metaEngine = metaEngine;
+  }
+
+  /**
+   * @param {string} path
+   * @returns
+   */
+  async load(path) {
+    const isExists = await _io.directory.exists(path);
+    if (!isExists) {
+      return;
+    }
+
+    const files = await _io.directory.read(path);
+    for (const entry of files) {
+      if (!entry.endsWith(".md")) {
+        continue;
+      }
+
+      const filePath = _io.path.combine(path, entry);
+      const isFileExists = await _io.file.exists(filePath);
+      if (!isFileExists) {
+        throw new Error(`Failed to read content file at ${filePath}`);
+      }
+
+      const contentFile = await this.#_loadFromFile(filePath);
+      this.#_cache.push(contentFile);
+    }
+
+    this.#_collectionsCache = null;
+    this.#_footerPoliciesCache = null;
+    this.#_contentIndexCache = null;
+  }
+
+  get count() {
+    return this.#_cache.length;
+  }
+
+  get files() {
+    return this.#_cache;
+  }
+
+  /**
+   * @returns {Record<string, Array<{ key: string, label: string, url: string, lang: string }>>}
+   */
+  buildFooterPolicies() {
+    if (this.#_footerPoliciesCache) {
+      return this.#_footerPoliciesCache;
+    }
+
+    if (this.count === 0) {
+      this.#_footerPoliciesCache = {};
+      return this.#_footerPoliciesCache;
+    }
+
+    /** @type {Record<string, Array<{ key: string, label: string, url: string, lang: string }>>} */
+    const policiesByLang = {};
+    const contentFiles = this.files;
+    for (const file of contentFiles) {
+      if (
+        !file.isValid ||
+        file.isDraft ||
+        !file.isPublished ||
+        file.category !== "policy"
+      ) {
+        continue;
+      }
+
+      const policy = {
+        lang: file.lang,
+        key: file.id,
+        label: file.menuLabel,
+        url: this.#_metaEngine.buildContentUrl(
+          file.canonical,
+          file.lang,
+          file.slug,
+        ),
+      };
+
+      if (!Array.isArray(policiesByLang[file.lang])) {
+        policiesByLang[file.lang] = [];
+      }
+
+      policiesByLang[file.lang].push(policy);
+    }
+
+    Object.keys(policiesByLang).forEach((lang) => {
+      policiesByLang[lang].sort((a, b) => a.label.localeCompare(b.label, lang));
+    });
+
+    this.#_footerPoliciesCache = policiesByLang;
+    return this.#_footerPoliciesCache;
+  }
+
+  /**
+   * @returns {Record<string, Record<string, { id: string, lang: string, title: string, canonical: string }>>}
+   */
+  buildContentIndex() {
+    if (this.#_contentIndexCache) {
+      return this.#_contentIndexCache;
+    }
+
+    if (this.count === 0) {
+      this.#_contentIndexCache = {};
+      return this.#_contentIndexCache;
+    }
+
+    /** @type {Record<string, Record<string, { id: string, lang: string, title: string, canonical: string }>>} */
+    const index = {};
+    const contentFiles = this.files;
+    for (const file of contentFiles) {
+      if (!file.isValid || file.isDraft || !file.isPublished || !file.id) {
+        continue;
+      }
+
+      if (!index[file.id]) {
+        index[file.id] = {};
+      }
+
+      index[file.id][file.lang] = {
+        id: file.id,
+        lang: file.lang,
+        title: file.title,
+        canonical: this.#_metaEngine.buildContentUrl(
+          file.canonical,
+          file.lang,
+          file.slug,
+        ),
+      };
+    }
+
+    this.#_contentIndexCache = index;
+    return this.#_contentIndexCache;
+  }
+
+  /**
+   * @returns {import("../types/index.d.ts").CollectionsByLang}
+   */
+  buildCategoryTagCollections() {
+    if (this.#_collectionsCache) {
+      return this.#_collectionsCache;
+    }
+
+    if (this.count === 0) {
+      this.#_collectionsCache = {};
+      return this.#_collectionsCache;
+    }
+
+    /** @type {import("../types/index.d.ts").CollectionsByLang} */
+    const pagesByLang = {};
+    const contentFiles = this.files;
+    for (const file of contentFiles) {
+      if (!file.isValid || file.isDraft || !file.isPublished) {
+        continue;
+      }
+
+      const contentSummary = new ContentSummary(file);
+      const summary = /** @type {import("../types/index.d.ts").CollectionEntry} */ ({
+        ...contentSummary.toObject(),
+        canonical: this.#_metaEngine.buildContentUrl(
+          file.canonical,
+          file.lang,
+          file.slug,
+        ),
+      });
+      const langStore = pagesByLang[file.lang] ?? (pagesByLang[file.lang] = {});
+
+      if (file.isPostTemplate && file.isFeatured) {
+        this.#_addCollectionEntry(langStore, "home", summary, "home");
+      }
+
+      if (file.category) {
+        this.#_addCollectionEntry(
+          langStore,
+          file.category,
+          summary,
+          "category",
+        );
+      }
+
+      for (const tag of file.tags) {
+        this.#_addCollectionEntry(langStore, tag, summary, "tag");
+      }
+
+      if (file.series) {
+        this.#_addCollectionEntry(
+          langStore,
+          file.series,
+          {
+            ...contentSummary.toObject(),
+            seriesTitle: file.seriesTitle,
+          },
+          "series",
+        );
+      }
+    }
+
+    this.#_collectionsCache = this.#_sortCollectionEntries(pagesByLang);
+    return this.#_collectionsCache;
+  }
+
+  /**
+   * @param {string} filePath
+   * @returns {Promise<ContentFile>}
+   */
+  async #_loadFromFile(filePath) {
+    const raw = await _io.file.read(filePath);
+    let isValid = false;
+
+    /**
+     * @type {{data: Record<string, unknown>, content: string}}
+     */
+    let matterResponse = { data: {}, content: "" };
+
+    try {
+      matterResponse = matter(raw);
+      isValid = true;
+    } catch {}
+
+    const { data, content } = matterResponse;
+    return new ContentFile(data, content, filePath, isValid);
+  }
+
+  /**
+   * @param {Record<string, import("../types/index.d.ts").CollectionEntry[]>} store
+   * @param {string} key
+   * @param {import("../types/index.d.ts").CollectionEntry} entry
+   * @param {string} type
+   */
+  #_addCollectionEntry(store, key, entry, type) {
+    if (!store[key]) {
+      store[key] = [];
+    }
+    store[key].push({
+      ...entry,
+      type,
+    });
+  }
+
+  /**
+   * @param {import("../types/index.d.ts").CollectionsByLang} collections
+   */
+  #_sortCollectionEntries(collections) {
+    /** @type {import("../types/index.d.ts").CollectionsByLang} */
+    const sorted = {};
+    Object.keys(collections).forEach((lang) => {
+      sorted[lang] = {};
+      Object.keys(collections[lang]).forEach((key) => {
+        sorted[lang][key] = collections[lang][key].slice().sort((a, b) => {
+          const aDate = Date.parse(String(a.date ?? "")) || 0;
+          const bDate = Date.parse(String(b.date ?? "")) || 0;
+          if (aDate === bDate) {
+            return (a.title ?? "").localeCompare(b.title ?? "", lang);
+          }
+          return bDate - aDate;
+        });
+      });
+    });
+    return sorted;
+  }
+}

package/registries/pageRegistry.js

@@ -0,0 +1,29 @@
+import { Page } from "../lib/page.js";
+
+export class PageRegistry {
+  /**
+   * @type {Page[]}
+   */
+  #_cache = [];
+
+  /**
+   * @param {Page} page
+   */
+  add(page) {
+    if (page instanceof Page) {
+      this.#_cache.push(page);
+    }
+  }
+
+  list() {
+    return [...this.#_cache];
+  }
+
+  get count() {
+    return this.#_cache.length;
+  }
+
+  clear() {
+    this.#_cache = [];
+  }
+}

package/registries/pluginRegistry.js

@@ -0,0 +1,94 @@
+import { exec as _exec, log as _log, config as _cfg } from "@shevky/base";
+import { Project } from "../lib/project.js";
+
+/** @typedef {import("../types/index.d.ts").PluginInstance} PluginInstance */
+/** @typedef {import("../types/index.d.ts").PluginLoadContext} PluginLoadContext */
+
+export class PluginRegistry {
+  /**
+   * @type {Map<string, PluginInstance>}
+   */
+  #_cache = new Map();
+
+  /**
+   * @type {Project}
+   */
+  #_project = new Project(process.cwd());
+
+  /**
+   * @param {string[]|null|undefined} names
+   * @returns {Promise<void>}
+   */
+  async load(names) {
+    const pluginNames = Array.isArray(names) ? names.filter(Boolean) : [];
+    if (!pluginNames.length) {
+      return;
+    }
+
+    const resolveBase = this.#_project.rootDir;
+    for (const pluginName of pluginNames) {
+      try {
+        const fromCwd = _exec.resolve(pluginName, resolveBase);
+        const loaded = fromCwd
+          ? await import(fromCwd)
+          : await import(pluginName);
+
+        /**
+         * @type {PluginInstance}
+         */
+        const instance = loaded?.default ?? loaded;
+
+        if (!instance || typeof instance !== "object") {
+          _log.warn(`Plugin cannot load correctly. Plugin name: ${pluginName}`);
+          continue;
+        }
+
+        /**
+         * @type {string}
+         */
+        const name =
+          typeof instance.name === "string" ? instance.name.trim() : "";
+        if (!name) {
+          _log.warn(
+            `Plugin cannot load correctly. Missing name: ${pluginName}`,
+          );
+          continue;
+        }
+
+        if (this.#_cache.has(name)) {
+          _log.warn(`Duplicate plugin name detected: ${name}`);
+          continue;
+        }
+
+        this.#_cache.set(name, instance);
+
+        if (instance.load) {
+          const loadContext = this.#_createContext();
+          await instance.load(loadContext);
+        }
+
+        _log.debug(`The plugin '${pluginName}' has been loaded.`);
+      } catch (error) {
+        _log.err(`Failed to load plugin '${pluginName}':`, error);
+      }
+    }
+  }
+
+  get count() {
+    return this.#_cache.size;
+  }
+
+  get plugins() {
+    return this.#_cache;
+  }
+
+  /**
+   * @returns {PluginLoadContext}
+   */
+  #_createContext() {
+    return {
+      config: _cfg,
+      paths: this.#_project.toObject(),
+    };
+  }
+}

package/registries/templateRegistry.js

@@ -0,0 +1,152 @@
+import { io as _io } from "@shevky/base";
+
+import { Template } from "../lib/template.js";
+
+export const TYPE_PARTIAL = "partial";
+export const TYPE_COMPONENT = "component";
+export const TYPE_LAYOUT = "layout";
+export const TYPE_TEMPLATE = "template";
+
+const MUSTACHE_EXT = ".mustache";
+
+export class TemplateRegistry {
+  /**
+   * @type {Map<string, Map<string, Template>>}
+   */
+  #_cache = new Map();
+
+  /**
+   * @param {string} directoryPath
+   */
+  async loadPartials(directoryPath) {
+    await this.#_loadDirectory(directoryPath, {
+      type: TYPE_PARTIAL,
+      keyPrefix: "partials/",
+      accept: (entry) => entry.startsWith("_") && entry.endsWith(MUSTACHE_EXT),
+    });
+  }
+
+  /**
+   * @param {string} directoryPath
+   */
+  async loadComponents(directoryPath) {
+    await this.#_loadDirectory(directoryPath, {
+      type: TYPE_COMPONENT,
+      keyPrefix: "components/",
+      accept: (entry) => entry.endsWith(MUSTACHE_EXT),
+    });
+  }
+
+  /**
+   * @param {string} directoryPath
+   */
+  async loadLayouts(directoryPath) {
+    await this.#_loadDirectory(directoryPath, {
+      type: TYPE_LAYOUT,
+      accept: (entry) => !entry.startsWith("_") && entry.endsWith(MUSTACHE_EXT),
+    });
+  }
+
+  /**
+   * @param {string} directoryPath
+   */
+  async loadTemplates(directoryPath) {
+    await this.#_loadDirectory(directoryPath, {
+      type: TYPE_TEMPLATE,
+      accept: (entry) => entry.endsWith(MUSTACHE_EXT),
+    });
+  }
+
+  /**
+   * @param {string} type
+   */
+  list(type) {
+    return Array.from(this.#_ensure(type).keys());
+  }
+
+  /**
+   * @param {string} type
+   * @param {string} key
+   */
+  get(type, key) {
+    const template = this.#_ensure(type).get(key);
+    if (!template) {
+      throw new Error(`Template not found: ${key}`);
+    }
+
+    return template.content;
+  }
+
+  /**
+   * @param {string} type
+   * @param {string} key
+   */
+  getTemplate(type, key) {
+    const template = this.#_ensure(type).get(key);
+    if (!template) {
+      throw new Error(`Template not found: ${key}`);
+    }
+
+    return template;
+  }
+
+  /**
+   * @param {string} type
+   */
+  getFiles(type) {
+    /** @type {Record<string, string>} */
+    const result = {};
+    for (const [key, template] of this.#_ensure(type).entries()) {
+      result[key] = template.content;
+    }
+
+    return result;
+  }
+
+  /**
+   * @param {string} type
+   */
+  getCount(type) {
+    return this.#_ensure(type).size;
+  }
+
+  /**
+   * @param {string} directoryPath
+   * @param {{ type: string, keyPrefix?: string, accept: (entry: string) => boolean }} options
+   */
+  async #_loadDirectory(directoryPath, options) {
+    const isExists = await _io.directory.exists(directoryPath);
+    if (!isExists) {
+      return;
+    }
+
+    const { type, keyPrefix = "", accept } = options;
+    const entries = await _io.directory.read(directoryPath);
+    for (const entry of entries) {
+      if (!accept(entry)) {
+        continue;
+      }
+
+      const key = `${keyPrefix}${entry.replace(`${MUSTACHE_EXT}`, "")}`;
+      const path = _io.path.combine(directoryPath, entry);
+      const raw = await _io.file.read(path);
+      
+      const template = new Template(key, type, path, raw);
+      this.#_ensure(type).set(key, template);
+    }
+  }
+
+  /**
+   * @param {string} type
+   * @returns {Map<string, Template>}
+   */
+  #_ensure(type) {
+    let bucket = this.#_cache.get(type);
+    if (!bucket) {
+      bucket = new Map();
+      this.#_cache.set(type, bucket);
+    }
+
+    return bucket;
+  }
+}