@marsx-dev/launcher 0.0.2 → 0.0.5

package/src/utils/fileUtils.ts

@@ -0,0 +1,54 @@
+import { promises as fs } from 'fs';
+import _ from 'lodash';
+import { Abortable } from 'node:events';
+import { Mode, ObjectEncodingOptions, OpenMode } from 'node:fs';
+import { Stream } from 'node:stream';
+import path from 'path';
+
+export async function listFilesRecursive(dir: string): Promise<string[]> {
+  const entries = await fs.readdir(dir);
+
+  const files = await Promise.all(
+    entries.map(async (entry): Promise<string[]> => {
+      const entryPath = path.resolve(dir, entry);
+      return (await fs.stat(entryPath)).isDirectory() ? listFilesRecursive(entryPath) : [entryPath];
+    }),
+  );
+  return _.flatten(files);
+}
+
+export async function isFile(filePath: string): Promise<boolean> {
+  try {
+    return (await fs.stat(filePath)).isFile();
+  } catch (e) {
+    return false;
+  }
+}
+
+export async function isDirectory(dirPath: string): Promise<boolean> {
+  try {
+    return (await fs.stat(dirPath)).isDirectory();
+  } catch (e) {
+    return false;
+  }
+}
+
+export async function writeFileMakeDir(
+  filePath: string,
+  data:
+    | string
+    | NodeJS.ArrayBufferView
+    | Iterable<string | NodeJS.ArrayBufferView>
+    | AsyncIterable<string | NodeJS.ArrayBufferView>
+    | Stream,
+  options?:
+    | (ObjectEncodingOptions & {
+        mode?: Mode | undefined;
+        flag?: OpenMode | undefined;
+      } & Abortable)
+    | BufferEncoding
+    | null,
+): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, data, options);
+}

package/src/utils/sfc.ts

@@ -0,0 +1,155 @@
+import { CompilerError } from '@vue/compiler-core';
+import JSON5 from 'json5';
+import _ from 'lodash';
+import path from 'path';
+import { escapeCloseTag, escapeHtmlAttr, parseVueLike, stableHtmlAttributes, stablePrettyJson, unescapeCloseTag } from './textUtils';
+
+export const METADATA_SECTION_ID = 'metadata';
+export const MARS_SFC_EXT = 'mars';
+
+const SAVE_EMPTY_SOURCES = true;
+
+export type SfcPath = {
+  folder: string;
+  name: string;
+  blockTypeName: string;
+  ext: string;
+  filePath: string;
+};
+
+export type SfcSource = {
+  source: string;
+  lang: keyof typeof LANG_TAG_MAP | string | undefined;
+  props?: Record<string, string | undefined>;
+  lineOffset?: number;
+};
+
+export type SfcBlock = { path: SfcPath } & (
+  | { metadata: Record<string, unknown>; jsons: Record<string, unknown>; sources: Record<string, SfcSource>; rawContent: null }
+  | { metadata: EmptyObject; jsons: EmptyObject; sources: EmptyObject; rawContent: Buffer }
+);
+
+export function parseSfcPath(filePath: string): SfcPath {
+  // Blog/BlogPost.page.mars => {folder:"Blog", name: "BlogPost", blockTypeName: "page", ext: "mars", fullName: "Blog.BlogPost"}
+  const originalParsed = path.parse(filePath);
+  const withoutExt = originalParsed.name;
+  const ext = originalParsed.ext.slice(1);
+
+  const parsed = path.parse(withoutExt);
+  if (!parsed.name || !parsed.ext) throw new Error(`Invalid block file path: ${filePath}`);
+  const blockTypeName = parsed.ext.slice(1);
+
+  return {
+    folder: originalParsed.dir,
+    name: parsed.name,
+    blockTypeName,
+    ext,
+    filePath,
+  };
+}
+
+export function serializeSfcPath(identity: SfcPath): string {
+  return path.join(identity.folder, `${identity.name}.${identity.blockTypeName}.${identity.ext}`);
+}
+
+type EmptyObject = {
+  [K in string]: never;
+};
+
+const LANG_TAG_MAP = {
+  html: 'html',
+  pug: 'template',
+  js: 'script',
+  jsx: 'script',
+  ts: 'script',
+  tsx: 'script',
+  css: 'style',
+  scss: 'style',
+  less: 'style',
+  sass: 'style',
+  stylus: 'style',
+  text: 'text',
+};
+
+export function parseSFC(filePath: string, content: Buffer): SfcBlock {
+  const sfcPath = parseSfcPath(filePath);
+  if (sfcPath.ext !== MARS_SFC_EXT) {
+    return { path: sfcPath, metadata: {}, jsons: {}, sources: {}, rawContent: content };
+  }
+
+  const block: SfcBlock = {
+    path: parseSfcPath(filePath),
+    metadata: {},
+    jsons: {},
+    sources: {},
+    rawContent: null,
+  };
+  const seenIds = new Set<string>();
+  const errors: (CompilerError | SyntaxError)[] = [];
+
+  for (const node of parseVueLike(content.toString('utf-8'), errors)) {
+    const { id: sectionId, lang, ...props } = node.props;
+
+    if (!sectionId) {
+      errors.push({ name: `missing-id`, message: `Id property is missing`, code: 0, loc: node.loc });
+      continue;
+    }
+    if (seenIds.has(sectionId)) {
+      errors.push({ name: `duplicate-id`, message: `Duplicate section id: ${sectionId}`, code: 0, loc: node.loc });
+      continue;
+    }
+    seenIds.add(sectionId);
+
+    if (node.tag === 'json') {
+      try {
+        const jsonData = JSON5.parse(node.content);
+        if (sectionId === METADATA_SECTION_ID) {
+          block.metadata = jsonData;
+        } else {
+          block.jsons[sectionId] = jsonData;
+        }
+      } catch (e) {
+        errors.push({ name: 'invalid-json', message: `${e}`, code: 0, loc: node.loc });
+      }
+    } else {
+      const source = unescapeCloseTag(node.content.slice(1, -1), node.tag);
+      const lineOffset = node.loc.start.line;
+      block.sources[sectionId] = { source, lang, props, lineOffset };
+    }
+  }
+
+  if (errors.length) {
+    throw new Error(`Parsing SFC ${filePath} failed with ${JSON.stringify(errors)}`);
+  }
+
+  return block;
+}
+
+export function serializeSfc(block: SfcBlock): { filePath: string; content: Buffer } {
+  const filePath = serializeSfcPath(block.path);
+  if (block.path.ext !== MARS_SFC_EXT) {
+    if (block.rawContent === null) throw new Error(`SfcBlock must have rawContent if ext!="${MARS_SFC_EXT}"`);
+    return { filePath, content: block.rawContent };
+  }
+
+  if (block.rawContent !== null) throw new Error(`SfcBlock cannot have rawContent if ext=="${MARS_SFC_EXT}"`);
+
+  let content = '';
+
+  for (const [name, source] of [[METADATA_SECTION_ID, block.metadata] as const, ..._.sortBy(Object.entries(block.jsons), e => e[0])]) {
+    const jsonStr = stablePrettyJson(source);
+    content += `<json id="${escapeHtmlAttr(name)}">\n${jsonStr}</json>\n\n`;
+  }
+
+  for (const [name, source] of _.sortBy(Object.entries(block.sources), e => e[0])) {
+    if (!SAVE_EMPTY_SOURCES && !source.source.trim()) continue;
+    const tag = (LANG_TAG_MAP as Record<string, string>)[source.lang || ''] || 'text';
+    const id = escapeHtmlAttr(name);
+    const lang = escapeHtmlAttr(source.lang || '');
+    const props = stableHtmlAttributes(source.props);
+    const text = escapeCloseTag(source.source, tag);
+    content += `<${tag} id="${id}" lang="${lang}"${props}>\n${text}\n</${tag}>\n\n`;
+  }
+
+  return { filePath, content: Buffer.from(content, 'utf-8') };
+}

package/src/utils/textUtils.ts

@@ -0,0 +1,82 @@
+import { CompilerError, TextModes } from '@vue/compiler-core';
+import * as CompilerDOM from '@vue/compiler-dom';
+import { NodeTypes } from '@vue/compiler-dom';
+import stringify from 'json-stable-stringify';
+import _ from 'lodash';
+import prettier, { Options } from 'prettier';
+
+export function assert(value: unknown, message = 'value must be defined'): asserts value {
+  if (!value) {
+    throw new Error(message);
+  }
+}
+
+export function escapeCloseTag(str: string, tag: string): string {
+  return str.replaceAll(`</${tag}>`, `</ ${tag}>`);
+}
+
+export function unescapeCloseTag(str: string, tag: string): string {
+  return str.replaceAll(`</ ${tag}>`, `</${tag}>`);
+}
+
+export function escapeHtmlAttr(str: string): string {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+const PRETTIER_JSON_CONFIG: Options = { parser: 'json5', printWidth: 120, trailingComma: 'all' };
+
+export function prettifyJson(json: string): string {
+  return prettier.format(`(${json})`, PRETTIER_JSON_CONFIG);
+}
+
+export function stableJson(data: unknown): string {
+  return stringify(data);
+}
+
+export function stablePrettyJson(data: unknown): string {
+  return prettifyJson(stableJson(data));
+}
+
+export function stableHtmlAttributes(attrs: Record<string, string | undefined | null> | undefined): string {
+  let result = '';
+  if (attrs) {
+    for (const [name, value] of _.sortBy(Object.entries(attrs), e => e[0])) {
+      if (value) {
+        result += ` ${name}="${escapeHtmlAttr(value)}"`;
+      }
+    }
+  }
+  return result;
+}
+
+export function parseVueLike(content: string, errors: (CompilerError | SyntaxError)[]) {
+  const ast = CompilerDOM.parse(content, {
+    // there are no components at SFC parsing level
+    isNativeTag: () => true,
+    // preserve all whitespaces
+    isPreTag: () => true,
+    getTextMode: () => TextModes.RAWTEXT,
+    onError: e => errors.push(e),
+  });
+
+  const result = [];
+
+  for (const node of ast.children) {
+    if (node.type === NodeTypes.ELEMENT) {
+      const child = node.children.length === 1 ? node.children[0] : null;
+      const content = child && child.type === NodeTypes.TEXT ? child.content : null;
+
+      if (content) {
+        const props: Record<string, string> = {};
+        for (const prop of node.props) {
+          if (prop.type === NodeTypes.ATTRIBUTE && prop.value) {
+            props[prop.name] = prop.value.content;
+          }
+        }
+        result.push({ tag: node.tag, props, content, loc: node.loc });
+      }
+    }
+  }
+
+  return result;
+}

package/src/utils/v3.ts

@@ -0,0 +1,104 @@
+import { SfcBlock } from './sfc';
+
+export type V3MongoBlock = {
+  Folder: string;
+  Name: string;
+  Type: string;
+  app?: { name: string };
+} & Record<string, unknown>;
+
+const SFC_FIELD_MAP: Record<string, string> = {
+  // JSONs
+  DataArgs: 'json',
+  Page: 'json',
+  pages: 'json',
+  blocks: 'json',
+  Config: 'json',
+  langs: 'json',
+  // Scripts
+  BlockFunction: 'ts',
+  Html: 'html',
+  HTML: 'html',
+  Jsx: 'tsx',
+  JsxTranspiled: 'js',
+  JsxTranspiledTranspiled: 'js',
+  JSX: 'tsx',
+  JSXTranspiled: 'js',
+  DemoJsx: 'tsx',
+  DemoJsxTranspiled: 'js',
+  Script: 'ts',
+  Css: 'css',
+  TestCode: 'ts',
+  JestDefinition: 'ts',
+  DataForScriptFunction: 'ts',
+  // Ignore (part of file path)
+  // _id: 'DELETE',
+  Name: 'DELETE',
+  Type: 'DELETE',
+  Folder: 'DELETE',
+  // Ignore (will be tracked by git)
+  app: 'DELETE',
+  Created: 'DELETE',
+  LastChanged: 'DELETE',
+  createdAt: 'DELETE',
+  createdBy: 'DELETE',
+  updatedAt: 'DELETE',
+  updatedBy: 'DELETE',
+  // ... rest of the fields will be saved in metadata
+};
+
+export function convertV3ToSfc(block: V3MongoBlock): SfcBlock {
+  const sfc: SfcBlock = {
+    path: {
+      folder: block.Folder,
+      name: block.Name,
+      blockTypeName: block.Type,
+      ext: 'vue',
+      filePath: '',
+    },
+    metadata: {},
+    jsons: {},
+    sources: {},
+    rawContent: null,
+  };
+  for (const [prop, value] of Object.entries(block)) {
+    const sfcLang = SFC_FIELD_MAP[prop] || 'METADATA';
+
+    switch (sfcLang) {
+      case 'json':
+        if (typeof value !== 'object' && !Array.isArray(value)) throw new Error(`Object or array is expected for ${prop} property`);
+        sfc.jsons[prop] = value;
+        break;
+      case 'DELETE':
+        break;
+      case 'METADATA':
+        sfc.metadata[prop] = value;
+        break;
+      default:
+        if (typeof value !== 'string') throw new Error(`String is expected for ${prop} property`);
+        sfc.sources[prop] = { source: value, lang: sfcLang };
+        break;
+    }
+  }
+
+  if (block.app) {
+    sfc.metadata['app'] = { name: block.app.name };
+  }
+  return sfc;
+}
+
+export function convertSfcToV3(sfc: SfcBlock): V3MongoBlock {
+  const block: V3MongoBlock = {
+    Name: sfc.path.name,
+    Type: sfc.path.blockTypeName,
+    Folder: sfc.path.folder,
+    ...sfc.metadata,
+    ...sfc.jsons,
+  };
+
+  for (const [key, value] of Object.entries(sfc.sources)) {
+    block[key] = value.source;
+  }
+
+  return block;
+}

package/dist/utils/utils.js

@@ -1,59 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeFileMakeDir = exports.isDirectory = exports.isFile = exports.listFilesRecursive = exports.escapeHtmlAttr = exports.unescapeCloseTag = exports.escapeCloseTag = exports.assert = void 0;
-const fs_1 = require("fs");
-const lodash_1 = __importDefault(require("lodash"));
-const path_1 = __importDefault(require("path"));
-function assert(value, message = 'value must be defined') {
-    if (!value) {
-        throw new Error(message);
-    }
-}
-exports.assert = assert;
-function escapeCloseTag(str, tag) {
-    return str.replaceAll(`</${tag}>`, `</ ${tag}>`);
-}
-exports.escapeCloseTag = escapeCloseTag;
-function unescapeCloseTag(str, tag) {
-    return str.replaceAll(`</ ${tag}>`, `</${tag}>`);
-}
-exports.unescapeCloseTag = unescapeCloseTag;
-function escapeHtmlAttr(str) {
-    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-}
-exports.escapeHtmlAttr = escapeHtmlAttr;
-async function listFilesRecursive(dir) {
-    const entries = await fs_1.promises.readdir(dir);
-    const files = await Promise.all(entries.map(async (entry) => {
-        const entryPath = path_1.default.resolve(dir, entry);
-        return (await fs_1.promises.stat(entryPath)).isDirectory() ? listFilesRecursive(entryPath) : [entryPath];
-    }));
-    return lodash_1.default.flatten(files);
-}
-exports.listFilesRecursive = listFilesRecursive;
-async function isFile(filePath) {
-    try {
-        return (await fs_1.promises.stat(filePath)).isFile();
-    }
-    catch (e) {
-        return false;
-    }
-}
-exports.isFile = isFile;
-async function isDirectory(dirPath) {
-    try {
-        return (await fs_1.promises.stat(dirPath)).isDirectory();
-    }
-    catch (e) {
-        return false;
-    }
-}
-exports.isDirectory = isDirectory;
-async function writeFileMakeDir(filePath, data, options) {
-    await fs_1.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
-    await fs_1.promises.writeFile(filePath, data, options);
-}
-exports.writeFileMakeDir = writeFileMakeDir;