@shevky/core 0.0.2 → 0.0.4

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;
+  }
+}

package/scripts/cli.js

@@ -65,10 +65,10 @@ function help() {
     },
     {
       header: "Project Details",
-      content: "Project Home: {underline https://tatoglu.net/project/shevky}",
+      content: "Project Home: {underline https://shevky.github.io}",
     },
     {
-      content: "GitHub: {underline https://github.com/fatihtatoglu/shevky}",
+      content: "GitHub: {underline https://github.com/shevky}",
     },
   ];
 

package/scripts/main.js

@@ -4,7 +4,7 @@ import _cli from "./cli.js";
 import _build from "./build.js";
 import _init from "./init.js";
 
-const VERSION = "0.0.1";
+const VERSION = "0.0.4";
 
 const __filename = _io.url.toPath(import.meta.url);
 const __dirname = _io.path.name(__filename);

package/types/command-line-args.d.ts

@@ -0,0 +1,20 @@
+declare module "command-line-args" {
+  export type OptionDefinition = {
+    name: string;
+    alias?: string;
+    type?: unknown;
+    description?: string;
+    defaultValue?: unknown;
+    multiple?: boolean;
+    defaultOption?: boolean;
+  };
+
+  export type CommandLineOptions = Record<string, unknown>;
+
+  function commandLineArgs(
+    options?: readonly OptionDefinition[],
+    argv?: readonly string[],
+  ): CommandLineOptions;
+
+  export default commandLineArgs;
+}

package/types/command-line-usage.d.ts

@@ -0,0 +1,12 @@
+declare module "command-line-usage" {
+  export type Section = {
+    header?: string;
+    content?: string | string[];
+    optionList?: unknown[];
+    group?: string | string[];
+  };
+
+  function commandLineUsage(sections: readonly Section[] | Section): string;
+
+  export default commandLineUsage;
+}

package/types/degit.d.ts

@@ -0,0 +1,15 @@
+declare module "degit" {
+  type DegitOptions = {
+    cache?: boolean;
+    force?: boolean;
+    verbose?: boolean;
+  };
+
+  type DegitEmitter = {
+    clone: (dest: string) => Promise<void>;
+  };
+
+  function degit(repo: string, options?: DegitOptions): DegitEmitter;
+
+  export default degit;
+}

package/types/index.d.ts

@@ -0,0 +1,98 @@
+import type {
+  BasePluginContext,
+  PluginHooks,
+  PluginLoadContext as BasePluginLoadContext,
+} from "@shevky/base";
+
+export type ProjectPaths = {
+  root: string;
+  src: string;
+  dist: string;
+  tmp: string;
+  content: string;
+  layouts: string;
+  components: string;
+  templates: string;
+  assets: string;
+  siteConfig: string;
+  i18nConfig: string;
+};
+
+export type PluginInstance = {
+  name: string;
+  version: string;
+  hooks: PluginHooks;
+  load: (ctx: PluginLoadContext) => void;
+};
+
+export type PluginLoadContext = BasePluginLoadContext;
+
+export type ContentHeaderLike = Record<string, any>;
+
+export type ContentBodyLike = {
+  content?: string;
+};
+
+export type ContentFileLike = {
+  header?: ContentHeaderLike;
+  body?: ContentBodyLike;
+  content?: string;
+  isValid?: boolean;
+  sourcePath?: string;
+};
+
+export interface PluginExecutionContext extends BasePluginContext {
+  paths: ProjectPaths;
+  contentFiles?: ContentFileLike[];
+  addContent?: (
+    input:
+      | ContentFileLike
+      | import("../lib/contentFile.js").ContentFile
+  ) => void;
+  pages?: CollectionsByLang;
+  contentIndex?: Record<
+    string,
+    Record<string, { id: string; lang: string; title: string; canonical: string }>
+  >;
+  footerPolicies?: Record<string, FooterPolicy[]>;
+}
+
+export type Placeholder = {
+  token: string;
+  marker: string;
+  html: string;
+};
+
+export type FooterPolicy = {
+  key: string;
+  label: string;
+  url: string;
+  lang: string;
+};
+
+export type ContentSummaryLike = {
+  id: string;
+  title: string;
+  slug: string;
+  lang: string;
+  canonical: string;
+  date: string | number | Date;
+  updated: string | number | Date;
+  description: string;
+  cover: string;
+  coverAlt: string;
+  coverCaption: string;
+  readingTime: number;
+  dateDisplay: string | null;
+  seriesTitle: string;
+};
+
+export type CollectionEntry = ContentSummaryLike & {
+  type?: string;
+  seriesTitle?: string;
+  canonical?: string;
+};
+
+export type CollectionsByLang = Record<string, Record<string, CollectionEntry[]>>;
+
+export type FrontMatter = Record<string, any>;