@marsx-dev/launcher 0.0.1 → 0.0.4

package/src/utils/utils.ts

@@ -0,0 +1,72 @@
+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 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;');
+}
+
+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/v3.ts

@@ -0,0 +1,105 @@
+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 = {
+    identity: {
+      folder: block.Folder,
+      name: block.Name,
+      blockTypeName: block.Type,
+      ext: 'vue',
+      fullName: '',
+      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.identity.name,
+    Type: sfc.identity.blockTypeName,
+    Folder: sfc.identity.folder,
+    ...sfc.metadata,
+    ...sfc.jsons,
+  };
+
+  for (const [key, value] of Object.entries(sfc.sources)) {
+    block[key] = value.source;
+  }
+
+  return block;
+}