@underpostnet/cyberia 3.2.90 → 3.3.73

package/test/unit/test-tiers.test.js

@@ -0,0 +1,193 @@
+'use strict';
+
+import { expect } from 'chai';
+import fs from 'node:fs';
+import {
+  TEST_TIERS,
+  UNDERPOST_TESTING,
+  coverageIncludeFactory,
+  coverageThresholdFactory,
+  resolveTestSelection,
+  testProjectsFactory,
+  testSuiteNames,
+} from '../../src/server/build/testing.js';
+
+// The table declares every tier the platform ships. A product build slices the
+// tree, so whether a tier's directory is present here is a catalog question,
+// asserted in catalog.test.js — these are about the table itself.
+describe('test tiers', () => {
+  it('names every tier uniquely', () => {
+    const names = TEST_TIERS.map(({ name }) => name);
+    expect(new Set(names).size).to.equal(names.length);
+  });
+
+  it('never leaves a tier on group order 0', () => {
+    // Vitest routes a single-worker project on the default 0 into a bucket it
+    // appends after every ordered group, which would run that tier last.
+    for (const { name, groupOrder } of TEST_TIERS) expect(groupOrder, name).to.be.greaterThan(0);
+  });
+
+  it('declares tiers in the order they run', () => {
+    const orders = TEST_TIERS.map(({ groupOrder }) => groupOrder);
+    expect(orders).to.deep.equal([...orders].sort((a, b) => a - b));
+  });
+
+  it('keeps delegated tiers in the last group', () => {
+    // They run after the Vitest pass, so an earlier group order would describe
+    // an execution order that does not happen.
+    const lastGroup = Math.max(...TEST_TIERS.map(({ groupOrder }) => groupOrder));
+    for (const { name, groupOrder, delegate } of TEST_TIERS) if (delegate) expect(groupOrder, name).to.equal(lastGroup);
+  });
+
+  it('exposes only non-delegated tiers as Vitest projects', () => {
+    const projects = testProjectsFactory().map(({ test }) => test.name);
+    expect(projects).to.deep.equal(TEST_TIERS.filter(({ delegate }) => !delegate).map(({ name }) => name));
+  });
+});
+
+describe('test tier selection', () => {
+  it('runs every tier when nothing is selected', () => {
+    for (const selector of ['', 'all']) {
+      const { projects, runVitest, delegated } = resolveTestSelection(selector);
+      // No explicit project list: Vitest runs them all, and a product build
+      // that strips one must not fail on a name it no longer ships.
+      expect(projects, selector).to.be.empty;
+      expect(runVitest, selector).to.equal(true);
+      expect(
+        delegated.map(({ name }) => name),
+        selector,
+      ).to.deep.equal(TEST_TIERS.filter(({ delegate }) => delegate).map(({ name }) => name));
+    }
+  });
+
+  it('expands a suite into its tiers', () => {
+    expect(resolveTestSelection('infra').projects).to.deep.equal(
+      TEST_TIERS.filter(({ name }) => name.startsWith('infra:')).map(({ name }) => name),
+    );
+  });
+
+  it('skips the Vitest pass when only delegated tiers are selected', () => {
+    const { runVitest, delegated } = resolveTestSelection('contracts');
+    expect(runVitest).to.equal(false);
+    expect(delegated.map(({ name }) => name)).to.deep.equal(['contracts']);
+  });
+
+  it('rejects an unknown selector instead of reporting an empty green run', () => {
+    expect(() => resolveTestSelection('not-a-suite')).to.throw(/unknown suite/);
+  });
+
+  it('offers every suite prefix as a selector', () => {
+    for (const suite of testSuiteNames()) expect(() => resolveTestSelection(suite), suite).to.not.throw();
+  });
+});
+
+describe('delegated tier commands', () => {
+  const delegated = TEST_TIERS.filter(({ delegate }) => delegate);
+
+  it('ships at least one delegated tier to assert against', () => {
+    expect(delegated).to.not.be.empty;
+  });
+
+  it('writes results only when a destination is given', () => {
+    for (const { name, delegate } of delegated) {
+      expect(delegate({}), name).to.not.include('--test-reporter-destination=/');
+      expect(delegate({ resultsPath: '/results/TEST-x.xml' }), name).to.include('/results/TEST-x.xml');
+    }
+  });
+
+  it('passes a name filter through to its runner', () => {
+    for (const { name, delegate } of delegated) expect(delegate({ grep: 'Burning' }), name).to.include('Burning');
+  });
+
+  // Under an outer `npm`, npx resolves the root project as the local prefix and
+  // pulls its own copy of a nested tool from the registry, which Hardhat then
+  // refuses to run as a non-local installation.
+  it('runs nested tooling from the nested install rather than through npx', () => {
+    for (const { name, delegate } of delegated) {
+      expect(delegate({}), name).to.not.match(/\bnpx\b/);
+      expect(delegate({}), name).to.include('./node_modules/.bin/');
+    }
+  });
+
+  // A directory left behind by an interrupted install passes a `-d` probe while
+  // holding none of the binaries the tier runs.
+  it('probes the installed binary before skipping the install', () => {
+    for (const { name, delegate } of delegated)
+      expect(delegate({}), name).to.match(/\[ -x node_modules\/\.bin\/[\w.-]+ \] \|\| npm ci/);
+  });
+});
+
+describe('coverage threshold', () => {
+  it('reports without gating until a run opts in', () => {
+    // A tier selection measures a slice of the tree, so the whole-suite number is
+    // not the bar it should be held to.
+    expect(coverageThresholdFactory({})).to.equal(null);
+    expect(coverageThresholdFactory({ COVERAGE_ENFORCE: '0' })).to.equal(null);
+  });
+
+  it('gates an opted-in run on the shipped threshold', () => {
+    for (const COVERAGE_ENFORCE of ['1', 'true'])
+      expect(coverageThresholdFactory({ COVERAGE_ENFORCE }), COVERAGE_ENFORCE).to.equal(
+        UNDERPOST_TESTING.coverageThreshold,
+      );
+  });
+
+  it('lets a repository ratchet its own bar', () => {
+    expect(coverageThresholdFactory({ COVERAGE_MIN: '25' })).to.equal(25);
+    // An unset repository variable arrives as an empty string, not as absent.
+    expect(coverageThresholdFactory({ COVERAGE_ENFORCE: '1', COVERAGE_MIN: '' })).to.equal(
+      UNDERPOST_TESTING.coverageThreshold,
+    );
+  });
+
+  it('refuses a bar that is not a percentage', () => {
+    for (const COVERAGE_MIN of ['eighty', '-1', '101'])
+      expect(() => coverageThresholdFactory({ COVERAGE_MIN }), COVERAGE_MIN).to.throw('COVERAGE_MIN');
+  });
+});
+
+describe('coverage scope', () => {
+  const vitestTiers = TEST_TIERS.filter(({ delegate }) => !delegate);
+
+  it('makes every Vitest tier accountable for the sources it drives', () => {
+    for (const { name, sources } of vitestTiers) expect(sources, name).to.not.be.empty;
+  });
+
+  it('leaves a delegated tier out of the Vitest report', () => {
+    // Its runner measures its own coverage, and this table only feeds Vitest.
+    for (const { name, sources, delegate } of TEST_TIERS) if (delegate) expect(sources, name).to.equal(undefined);
+  });
+
+  it('points every glob at something this tree ships', () => {
+    // A source that moved leaves the tier silently measuring nothing, which
+    // reads as coverage rather than as the missing measurement it is. A product
+    // build slices the tree, so only tiers it kept are asserted.
+    for (const { name, directory, sources } of vitestTiers) {
+      if (!fs.existsSync(directory)) continue;
+      for (const glob of sources) expect(fs.globSync(glob), `${name}: ${glob}`).to.not.be.empty;
+    }
+  });
+
+  it('measures every tier when the run selects none', () => {
+    const everySource = new Set(vitestTiers.flatMap(({ sources }) => sources));
+    expect(coverageIncludeFactory([])).to.have.members([...everySource]);
+  });
+
+  it('measures only the selected tiers', () => {
+    const unit = TEST_TIERS.find(({ name }) => name === 'unit').sources;
+    for (const argv of [['--project', 'unit'], ['--project=unit']])
+      expect(coverageIncludeFactory(['npx', 'vitest', 'run', ...argv, '--coverage']), argv.join(' ')).to.deep.equal(
+        unit,
+      );
+  });
+
+  it('counts a source two tiers drive once', () => {
+    const include = coverageIncludeFactory(['--project', 'infra:3-cluster', '--project', 'infra:4-ingress']);
+    expect(new Set(include).size).to.equal(include.length);
+    expect(include).to.include('src/server/runtime/conf.js');
+  });
+
+  it('rejects a selection that matches no tier', () => {
+    expect(() => coverageIncludeFactory(['--project', 'not-a-tier'])).to.throw(/unknown suite/);
+  });
+});

package/vitest.config.js

@@ -0,0 +1,58 @@
+import { defineConfig } from 'vitest/config';
+import {
+  UNDERPOST_TESTING,
+  coverageIncludeFactory,
+  coverageThresholdFactory,
+  testProjectsFactory,
+} from './src/server/build/testing.js';
+
+const allureResultsDirectory = process.env[UNDERPOST_TESTING.allureResultsEnvKey];
+const coverageThreshold = coverageThresholdFactory(process.env);
+const coverageInclude = coverageIncludeFactory(process.argv);
+
+// Spread into every tier: a Vitest project inherits nothing from the root
+// `test` block, and only `coverage` and `reporters` are read from it.
+const projectDefaults = {
+  // Mocha's `describe`/`it` and the hooks stay global, so the suites read the
+  // same either side of the migration and carry no runner import.
+  globals: true,
+  environment: 'node',
+  // A tier is only meaningful if its failures are attributable to it, and a
+  // suite that reads `dd.routes` or binds a fixed port cannot share a worker
+  // with another doing the same.
+  fileParallelism: false,
+  ...(allureResultsDirectory ? { setupFiles: ['allure-vitest/setup'] } : {}),
+};
+
+export default defineConfig({
+  test: {
+    reporters: [
+      'default',
+      ...(allureResultsDirectory ? [['allure-vitest/reporter', { resultsDir: allureResultsDirectory }]] : []),
+    ],
+    coverage: {
+      provider: 'v8',
+      reportsDirectory: UNDERPOST_TESTING.coverageDirectory,
+      // `lcov` is what Coveralls ingests, `json` is what a merged multi-job
+      // report is assembled from, `text` is what a local run reads.
+      reporter: ['text', 'lcov', 'json'],
+      // Written even when the run fails: the coverage workflows upload the report
+      // from a job the threshold step is meant to fail, and without it the badge
+      // freezes at the last passing build instead of moving with the tree.
+      reportOnFailure: true,
+      // The tiers in the selection decide what is measured, so a partial run
+      // reports the slice it drives and the whole run reports the whole of it —
+      // rather than every module the CLI barrel drags into a worker on import.
+      include: coverageInclude,
+      // Only the suites themselves: an `include` whitelist already keeps
+      // dependencies, bundles and generated assets out, and a directory pattern
+      // here is not anchored to the root — `test/**` also excluded the API
+      // surfaces named `test`, so the tier covering them reported nothing.
+      exclude: ['**/*.{test,spec}.js'],
+      // Absent unless the run opted in, so a single-tier run reports its slice
+      // instead of failing against a number it never measured.
+      ...(coverageThreshold === null ? {} : { thresholds: { lines: coverageThreshold } }),
+    },
+    projects: testProjectsFactory(projectDefaults),
+  },
+});

package/.nycrc

@@ -1,9 +0,0 @@
-{
-  "exclude": [],
-  "include": ["test"],
-  "output": "reports",
-  "reporter": ["html", "text", "lcov", "text-lcov", "cobertura"],
-  "sourceMap": true,
-  "instrument": true,
-  "all": true
-}

package/manifests/cronjobs/dd-cron/dd-cron-dns.yaml

@@ -1,48 +0,0 @@
-apiVersion: batch/v1
-kind: CronJob
-metadata:
-  name: dd-cron-dns
-  namespace: default
-  labels:
-    app: dd-cron-dns
-    managed-by: underpost
-spec:
-  schedule: "* * * * *"
-  concurrencyPolicy: Forbid
-  startingDeadlineSeconds: 200
-  successfulJobsHistoryLimit: 3
-  failedJobsHistoryLimit: 1
-  suspend: false
-  jobTemplate:
-    spec:
-      template:
-        metadata:
-          labels:
-            app: dd-cron-dns
-            managed-by: underpost
-        spec:
-          containers:
-            - name: dd-cron-dns
-              image: underpost/underpost-engine:v3.2.90
-              command:
-                - /bin/sh
-                - -c
-                - >
-                  cd /home/dd/engine &&
-                  node bin env dd-cron production &&
-                  node bin cron dd-cron dns --git --kubeadm 
-              volumeMounts:
-                - mountPath: /home/dd/engine
-                  name: underpost-cron-container-volume
-                - mountPath: /usr/lib/node_modules/underpost
-                  name: underpost-share-env
-          volumes:
-            - hostPath:
-                path: /home/dd/engine
-                type: Directory
-              name: underpost-cron-container-volume
-            - hostPath:
-                path: /root/.nvm/versions/node/v24.15.0/lib/node_modules/underpost
-                type: DirectoryOrCreate
-              name: underpost-share-env
-          restartPolicy: OnFailure

package/manifests/mongodb/pv-pvc.yaml

@@ -1,59 +0,0 @@
-apiVersion: v1
-kind: PersistentVolume
-metadata:
-  name: mongodb-pv-0
-  labels:
-    app: mongodb
-spec:
-  capacity:
-    storage: 5Gi
-  accessModes:
-    - ReadWriteOnce
-  persistentVolumeReclaimPolicy: Retain
-  storageClassName: mongodb-storage-class
-  claimRef:
-    namespace: default
-    name: mongodb-storage-mongodb-0
-  hostPath:
-    path: /data/mongodb/v0
-    type: DirectoryOrCreate
----
-apiVersion: v1
-kind: PersistentVolume
-metadata:
-  name: mongodb-pv-1
-  labels:
-    app: mongodb
-spec:
-  capacity:
-    storage: 5Gi
-  accessModes:
-    - ReadWriteOnce
-  persistentVolumeReclaimPolicy: Retain
-  storageClassName: mongodb-storage-class
-  claimRef:
-    namespace: default
-    name: mongodb-storage-mongodb-1
-  hostPath:
-    path: /data/mongodb/v1
-    type: DirectoryOrCreate
----
-apiVersion: v1
-kind: PersistentVolume
-metadata:
-  name: mongodb-pv-2
-  labels:
-    app: mongodb
-spec:
-  capacity:
-    storage: 5Gi
-  accessModes:
-    - ReadWriteOnce
-  persistentVolumeReclaimPolicy: Retain
-  storageClassName: mongodb-storage-class
-  claimRef:
-    namespace: default
-    name: mongodb-storage-mongodb-2
-  hostPath:
-    path: /data/mongodb/v2
-    type: DirectoryOrCreate

package/scripts/link-local-underpost-cli.sh

@@ -1,6 +0,0 @@
-
-#!/usr/bin/env bash
-set -euo pipefail
-
-cd /home/dd && underpost clone underpostnet/pwa-microservices-template
-cd /home/dd/pwa-microservices-template && npm install && npm link

package/src/api/user/user.build.js

@@ -1,16 +0,0 @@
-import fs from 'fs-extra';
-import { faBase64Png, getBufferPngText } from '../../server/client-icons.js';
-
-process.exit(0);
-
-fs.writeFileSync(
-  './tmp/api-user-invalid-token.png',
-  await getBufferPngText({ text: 'Invalid token', textColor: '#ff0000' }),
-  'utf8',
-);
-fs.writeFileSync(
-  './tmp/api-user-recover.png',
-  Buffer.from(faBase64Png('rotate-left', 50, 50, '#ffffff'), 'base64'),
-  'utf8',
-);
-fs.writeFileSync('./tmp/api-user-check.png', Buffer.from(faBase64Png('check', 50, 50), 'base64'), 'utf8');

package/src/cli/env.js

@@ -1,177 +0,0 @@
-/**
- * Environment module for managing the environment variables of the underpost root
- * @module src/cli/env.js
- * @namespace UnderpostEnv
- */
-
-import { getNpmRootPath, writeEnv } from '../server/conf.js';
-import fs from 'fs-extra';
-import { loggerFactory } from '../server/logger.js';
-import dotenv from 'dotenv';
-import { pbcopy } from '../server/process.js';
-
-const logger = loggerFactory(import.meta);
-
-/**
- * Guards an env file path against stale directory artifacts.
- * Removes the path if it exists as a directory (e.g. `.env/` created by a previous EISDIR bug).
- * @param {string} envPath - The path to the environment file.
- * @memberof UnderpostEnv
- */
-const guardEnvPath = (envPath) => {
-  if (fs.existsSync(envPath) && !fs.statSync(envPath).isFile()) {
-    logger.warn(`Removing stale directory at env path: ${envPath}`);
-    fs.removeSync(envPath);
-  }
-};
-
-/**
- * @class UnderpostRootEnv
- * @description Manages the environment variables of the underpost root.
- * @memberof UnderpostEnv
- */
-class UnderpostRootEnv {
-  static API = {
-    /**
-     * @method set
-     * @description Sets an environment variable in the underpost root environment.
-     * @param {string} key - The key of the environment variable to set.
-     * @param {string} value - The value of the environment variable to set.
-     * @param {object} options - Options for setting the environment variable.
-     * @param {string} [options.deployId=''] - Deployment ID associated with the environment variable.
-     * @param {boolean} [options.build=false] - If true, sets the environment variable using custom --deploy-id or all dd.router deploy ids configured.
-     * @memberof UnderpostEnv
-     */
-    set(key, value, options = { deployId: '', build: false }) {
-      const _set = (envPath, key, value) => {
-        guardEnvPath(envPath);
-        let env = {};
-        if (fs.existsSync(envPath)) env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
-        env[key] = value;
-        writeEnv(envPath, env);
-      };
-      if (options.build) {
-        const deployIdList = options.deployId
-          ? [options.deployId]
-          : fs.existsSync(`./engine-private/deploy/dd.router`)
-            ? fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(',')
-            : [DEFAULT_DEPLOY_ID];
-        for (const deployId of deployIdList)
-          for (const envFile of ['test', 'development', 'production'])
-            _set(`./engine-private/conf/${deployId}/.env.${envFile}`, key, value);
-        return;
-      }
-      const exeRootPath = `${getNpmRootPath()}/underpost`;
-      fs.ensureDirSync(exeRootPath);
-      const envPath = `${exeRootPath}/.env`;
-      _set(envPath, key, value);
-    },
-    /**
-     * @method delete
-     * @description Deletes an environment variable from the underpost root environment.
-     * @param {string} key - The key of the environment variable to delete.
-     * @memberof UnderpostEnv
-     */
-    delete(key) {
-      const exeRootPath = `${getNpmRootPath()}/underpost`;
-      const envPath = `${exeRootPath}/.env`;
-      guardEnvPath(envPath);
-      let env = {};
-      if (fs.existsSync(envPath)) env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
-      delete env[key];
-      writeEnv(envPath, env);
-    },
-    /**
-     * @method get
-     * @description Gets an environment variable from the underpost root environment.
-     * @param {string} key - The key of the environment variable to get.
-     * @param {string} value - The value of the environment variable to get.
-     * @param {object} options - Options for getting the environment variable.
-     * @param {boolean} [options.plain=false] - If true, returns the environment variable value as a string.
-     * @param {boolean} [options.disableLog=false] - If true, disables logging of the environment variable value.
-     * @param {boolean} [options.copy=false] - If true, copies the environment variable value to the clipboard.
-     * @memberof UnderpostEnv
-     */
-    get(key, value, options = { plain: false, disableLog: false, copy: false }) {
-      const exeRootPath = `${getNpmRootPath()}/underpost`;
-      const envPath = `${exeRootPath}/.env`;
-      if (!fs.existsSync(envPath) || !fs.statSync(envPath).isFile()) return undefined;
-      const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
-      if (!options.disableLog)
-        options?.plain === true ? console.log(env[key]) : logger.info(`${key}(${typeof env[key]})`, env[key]);
-      if (options.copy === true) pbcopy(env[key]);
-      return env[key];
-    },
-    /**
-     * @method list
-     * @description Lists all environment variables in the underpost root environment.
-     * @param {string} key - Not used for list operation.
-     * @param {string} value - Not used for list operation.
-     * @param {object} options - Options for listing environment variables.
-     * @param {string} [options.filter] - Filter keyword to match against keys or values.
-     * @memberof UnderpostEnv
-     */
-    list(key, value, options = {}) {
-      const exeRootPath = `${getNpmRootPath()}/underpost`;
-      const envPath = `${exeRootPath}/.env`;
-      guardEnvPath(envPath);
-      if (!fs.existsSync(envPath)) {
-        logger.warn(`Empty environment variables`);
-        return {};
-      }
-      let env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
-
-      // Apply filter if provided
-      if (options.filter) {
-        const filterKeyword = options.filter.toLowerCase();
-        const filtered = {};
-        for (const [envKey, envValue] of Object.entries(env)) {
-          const keyMatch = envKey.toLowerCase().includes(filterKeyword);
-          const valueMatch = String(envValue).toLowerCase().includes(filterKeyword);
-          if (keyMatch || valueMatch) {
-            filtered[envKey] = envValue;
-          }
-        }
-        env = filtered;
-        logger.info(`underpost root (filtered by: ${options.filter})`, env);
-      } else {
-        logger.info('underpost root', env);
-      }
-
-      return env;
-    },
-    /**
-     * @method clean
-     * @description Cleans the underpost root environment by removing the environment file.
-     * @param {object} options - Options for cleaning the environment.
-     * @param {Array<string>} [options.keepKeys=[]] - List of keys to keep in the environment file. If provided, only these keys will be retained.
-     * @memberof UnderpostEnv
-     */
-    clean(options = { keepKeys: [] }) {
-      const { keepKeys } = options;
-      const exeRootPath = `${getNpmRootPath()}/underpost`;
-      const envPath = `${exeRootPath}/.env`;
-      if (keepKeys && keepKeys.length > 0 && fs.existsSync(envPath)) {
-        const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
-        const filteredEnv = Object.fromEntries(Object.entries(env).filter(([key]) => keepKeys.includes(key)));
-        writeEnv(envPath, filteredEnv);
-      } else {
-        fs.removeSync(envPath);
-      }
-    },
-    /**
-     * @method isInsideContainer
-     * @description Detects whether the current process is running inside a container.
-     * Checks for Kubernetes service injection or Docker's .dockerenv marker.
-     * @returns {boolean} True if running inside a container.
-     * @memberof UnderpostEnv
-     */
-    isInsideContainer() {
-      return !!process.env.KUBERNETES_SERVICE_HOST || fs.existsSync('/.dockerenv');
-    },
-  };
-}
-
-export default UnderpostRootEnv;
-
-export { guardEnvPath };

package/src/client/components/core/Blockchain.js

@@ -1,41 +0,0 @@
-import { BlockChainService } from '../../services/blockchain/blockchain.service.js';
-import { BtnIcon } from './BtnIcon.js';
-import { dynamicCol } from './Css.js';
-import { EventsUI } from './EventsUI.js';
-import { Input } from './Input.js';
-import { Translate } from './Translate.js';
-
-const BlockChainManagement = {
-  Render: async function (options) {
-    setTimeout(() => {
-      EventsUI.onClick(`.btn-upload-blockchain`, async () => {
-        // const { result, status } = new BlockChainService.post();
-      });
-    });
-    return html` ${dynamicCol({ containerSelector: options.idModal, id: 'blockchain' })}
-      <div class="fl">
-        <div class="in fll blockchain-col-a">
-          <div class="in section-mp">
-            <div class="in sub-title-modal"><i class="fa-solid fa-sliders"></i> ${Translate.Render('config')}</div>
-            <div class="in">
-              ${await Input.Render({
-                id: `blockchain-seed`,
-                label: html`<i class="fa-solid fa-pen-to-square"></i> ${Translate.Render('blockchain-seed')}`,
-                containerClass: 'section-mp width-mini-box input-container',
-                placeholder: true,
-              })}
-              ${await BtnIcon.Render({
-                class: `inl section-mp btn-custom btn-upload-blockchain`,
-                label: html`<i class="fas fa-plus"></i> ${Translate.Render(`create`)}`,
-              })}
-            </div>
-          </div>
-        </div>
-        <div class="in fll blockchain-col-b">
-          <div class="in section-mp"></div>
-        </div>
-      </div>`;
-  },
-};
-
-export { BlockChainManagement };

package/src/client/components/core/Blog.js

@@ -1,9 +0,0 @@
-import { RichText } from './RichText.js';
-
-const Blog = {
-  Render: async function () {
-    return html`${await RichText.Render()}`;
-  },
-};
-
-export { Blog };