@eodash/eodash 5.0.0-alpha.2.3 → 5.0.0-alpha.2.5

package/bin/utils.js

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-
-import { existsSync, readFileSync } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { searchForWorkspaceRoot, createLogger } from 'vite';
-import { Command } from 'commander';
-
-export const rootPath = searchForWorkspaceRoot(process.cwd());
-const cli = new Command('eodash')
-
-const pkg = JSON.parse(
-  readFileSync(
-    path.join(rootPath, 'package.json')
-    , 'utf-8')
-);
-
-/**
- * CLI flags object
- * @typedef {Object} Options
- * @property {string | false} publicDir
- * @property {string} outDir
- * @property {string} entryPoint
- * @property {string} widgets
- * @property {string} cacheDir
- * @property {string} runtime
- * @property {string} base
- * @property {string | number} port
- * @property {boolean} open
- * @property {boolean | string} host
- * @property {string} config
- * @property {boolean} lib
- */
-cli.version(pkg.version, '-v, --version', 'output the current version')
-  .option('--publicDir <path>', 'path to statically served assets folder')
-  .option('--no-publicDir', 'stop serving static assets')
-  .option('--outDir <path>', 'minified output folder')
-  .option('-e, --entryPoint <path>', 'file exporting `createEodash`')
-  .option('-w, --widgets <path>', 'folder that contains vue components as internal widgets')
-  .option('--cacheDir <path>', 'cache folder')
-  .option('-r, --runtime <path>', 'file exporting eodash client runtime config')
-  .option('-b, --base <path>', 'base public path')
-  .option('-p, --port <port>', 'serving  port')
-  .option('-o, --open', 'open default browser when the server starts')
-  .option('-c, --config <path>', 'path to eodash server and build configuration file')
-  .option('--host [IP address]', 'specify which IP addresses the server should listen on')
-  .option('-l, --lib', 'builds eodash as a web component library')
-  .option('--no-lib', 'builds eodash as an SPA')
-  .option('--no-host', 'do not expose server to the network')
-  .parse(process.argv)
-
-
-export const userConfig = await getUserConfig(cli.opts(), process.argv?.[2])
-
-export const appPath = fileURLToPath(new URL("..", import.meta.url)),
-  publicPath = userConfig.publicDir ? path.resolve(rootPath, userConfig.publicDir) : path.join(rootPath, './public'),
-  srcPath = path.join(rootPath, "/src"),
-  runtimeConfigPath = userConfig.runtime ? path.resolve(rootPath, userConfig.runtime) : path.join(srcPath, "./runtime.js"),
-  entryPath = userConfig.entryPoint ? path.resolve(rootPath, userConfig.entryPoint) : path.join(srcPath, "/main.js"),
-  internalWidgetsPath = userConfig.widgets ? path.resolve(rootPath, userConfig.widgets) : path.join(srcPath, "widgets"),
-  dotEodashPath = path.join(rootPath, "/.eodash"),
-  buildTargetPath = userConfig.outDir ? path.resolve(rootPath, userConfig.outDir) : path.join(dotEodashPath, '/dist'),
-  cachePath = userConfig.cacheDir ? path.resolve(rootPath, userConfig.cacheDir) : path.join(dotEodashPath, 'cache');
-
-
-export const logger = createLogger(undefined, { prefix: '[eodash]' })
-
-/**
- * @param {Options} options
- * @param {string | undefined} command
- */
-async function getUserConfig(options, command) {
-  let eodashCLiConfigFile = options.config ? path.resolve(rootPath, options.config) : path.join(rootPath, 'eodash.config.js');
-  /** @type {import("./types").EodashConfig} */
-  let config = {};
-  if (existsSync(eodashCLiConfigFile)) {
-    config = await import(eodashCLiConfigFile).then(config => {
-      if (config.default instanceof Function) {
-        return config.default()
-      } else {
-        return config.default
-      }
-    }).catch(err => {
-      console.error(err);
-    })
-  } else {
-    eodashCLiConfigFile = null
-  }
-
-  return {
-    base: options.base ?? config?.base,
-    port: Number(options.port ?? config?.[command]?.port),
-    host: options.host ?? config?.[/**@type {"dev"|"preview"} */(command)]?.host,
-    open: options.open ?? config?.[/**@type {"dev"|"preview"} */(command)]?.open,
-    cacheDir: options.cacheDir ?? config?.cacheDir,
-    entryPoint: options.entryPoint ?? config?.entryPoint,
-    outDir: options.outDir ?? config?.outDir,
-    publicDir: options.publicDir ?? config?.publicDir,
-    runtime: options.runtime ?? config?.runtime,
-    widgets: options.widgets ?? config?.widgets,
-    lib: options.lib ?? config?.lib
-  }
-}

package/core/components/DashboardLayout.vue

@@ -1,36 +0,0 @@
-<template>
-  <v-main>
-    <eox-layout :gap="eodash.template.gap ?? 2">
-      <eox-layout-item v-if="bgWidget.component" style="z-index: 0;" x="0" y="0" h="12" w="12">
-        <Suspense suspensible>
-          <component id="bg-widget" :is="bgWidget.component" v-bind="bgWidget.props" />
-        </Suspense>
-      </eox-layout-item>
-      <template v-for="(config, idx) in widgetsConfig" :key="idx">
-        <eox-layout-item v-if="importedWidgets[idx].value.component"
-          style="position: relative; overflow: visible; z-index: 1; border-radius: 0px; background: rgb(var(--v-theme-surface))"
-          :x="config.layout.x" :y="config.layout.y" :h="config.layout.h" :w="config.layout.w">
-
-          <Suspense suspensible>
-            <component :key="importedWidgets[idx].value.id" :is="importedWidgets[idx].value.component"
-              v-bind="importedWidgets[idx].value.props" />
-          </Suspense>
-        </eox-layout-item>
-      </template>
-    </eox-layout>
-  </v-main>
-</template>
-<script setup>
-import { eodashKey } from '@/utils/keys';
-import { inject } from 'vue';
-import { useDefineWidgets } from '@/composables/DefineWidgets'
-import '@eox/layout'
-
-const eodash = /** @type {import("@/types").Eodash} */ (inject(eodashKey))
-
-const [bgWidget] = useDefineWidgets([eodash.template?.background])
-
-const widgetsConfig = eodash.template?.widgets
-
-const importedWidgets = useDefineWidgets(widgetsConfig)
-</script>

package/core/utils/index.js

@@ -1,28 +0,0 @@
-/**
- * loads font in the app using `webfontloader`
- * @param {string} [family="Roboto"]
- * @param {string} [link]
- * @returns {Promise<string>} - font family name
- * @see {@link "https://github.com/typekit/webfontloader "}
- */
-export const loadFont = async (family = "Roboto", link) => {
-  const WebFontLoader = (await import('webfontloader')).default;
-  if (link) {
-    WebFontLoader.load({
-      custom: {
-        // Use FVD notation to include families https://github.com/typekit/fvd
-        families: [family],
-        // Path to stylesheet that defines font-face
-        urls: [link],
-      },
-    });
-  }
-  else {
-    WebFontLoader.load({
-      google: {
-        families: [family]
-      }
-    });
-  }
-  return family;
-};

package/dist/DashboardLayout-lzEvtalW.js

@@ -1,148 +0,0 @@
-import { x, W as w, X as h, _ as e, $ as n, a0 as u, a9 as _, a2 as t, a5 as d, a1 as c, a3 as g, d as m, a4 as y, F as b, a6 as f } from "./asWebComponent-fqvymeM-.js";
-import { V as v } from "./VMain-COrg6UtF.js";
-class k extends HTMLElement {
-  static get observedAttributes() {
-    return ["gap"];
-  }
-  constructor() {
-    super(), this.attachShadow({ mode: "open" }), this.render();
-  }
-  render() {
-    this.shadowRoot.innerHTML = `
-    <style>
-      :host {
-        display: grid;
-        padding: ${this.getAttribute("gap") || 0}px;
-        height: 100%;
-        box-sizing: border-box;
-        gap: ${this.getAttribute("gap") || "0"}px;
-        grid-template-columns: repeat(12, 1fr);
-        grid-template-rows: repeat(12, 1fr);
-      }
-    </style>
-    <slot></slot>
-  `;
-  }
-  attributeChangedCallback(a, o, s) {
-    o !== s && (this[a] = s), this.render();
-  }
-}
-class A extends HTMLElement {
-  static get observedAttributes() {
-    return ["x", "y", "w", "h"];
-  }
-  constructor() {
-    super(), this.attachShadow({ mode: "open" }), this.render();
-  }
-  render() {
-    this.shadowRoot.innerHTML = `
-      <style>
-        :host {
-          background: lightgrey;
-          border: 1px solid darkgrey;
-          border-radius: 4px;
-          padding: 4px 8px;
-          overflow: hidden;
-
-
-          grid-column: ${parseInt(this.getAttribute("x")) + 1} / span ${this.getAttribute("w")};
-          grid-row: ${parseInt(this.getAttribute("y")) + 1} / span ${this.getAttribute("h")};
-        }
-      </style>
-      <slot></slot>
-    `;
-  }
-  attributeChangedCallback(a, o, s) {
-    o !== s && (this[a] = s), this.render();
-  }
-}
-customElements.define("eox-layout", k);
-customElements.define("eox-layout-item", A);
-const C = ["gap"], $ = {
-  key: 0,
-  style: { "z-index": "0" },
-  x: "0",
-  y: "0",
-  h: "12",
-  w: "12"
-}, L = ["x", "y", "h", "w"], T = {
-  __name: "DashboardLayout",
-  setup(p) {
-    const a = (
-      /** @type {import("@/types").Eodash} */
-      x(w)
-    ), [o] = h([a.template?.background]), s = a.template?.widgets, i = h(s);
-    return (E, M) => (e(), n(v, null, {
-      default: u(() => [
-        _("eox-layout", {
-          gap: t(a).template.gap ?? 2
-        }, [
-          t(o).component ? (e(), d("eox-layout-item", $, [
-            (e(), n(c, { suspensible: "" }, {
-              default: u(() => [
-                (e(), n(
-                  g(t(o).component),
-                  m({ id: "bg-widget" }, t(o).props),
-                  null,
-                  16
-                  /* FULL_PROPS */
-                ))
-              ]),
-              _: 1
-              /* STABLE */
-            }))
-          ])) : y("v-if", !0),
-          (e(!0), d(
-            b,
-            null,
-            f(t(s), (l, r) => (e(), d(
-              b,
-              { key: r },
-              [
-                t(i)[r].value.component ? (e(), d("eox-layout-item", {
-                  key: 0,
-                  style: { position: "relative", overflow: "visible", "z-index": "1", "border-radius": "0px", background: "rgb(var(--v-theme-surface))" },
-                  x: l.layout.x,
-                  y: l.layout.y,
-                  h: l.layout.h,
-                  w: l.layout.w
-                }, [
-                  (e(), n(
-                    c,
-                    { suspensible: "" },
-                    {
-                      default: u(() => [
-                        (e(), n(
-                          g(t(i)[r].value.component),
-                          m({
-                            key: t(i)[r].value.id
-                          }, t(i)[r].value.props),
-                          null,
-                          16
-                          /* FULL_PROPS */
-                        ))
-                      ]),
-                      _: 2
-                      /* DYNAMIC */
-                    },
-                    1024
-                    /* DYNAMIC_SLOTS */
-                  ))
-                ], 8, L)) : y("v-if", !0)
-              ],
-              64
-              /* STABLE_FRAGMENT */
-            ))),
-            128
-            /* KEYED_FRAGMENT */
-          ))
-        ], 8, C)
-      ]),
-      _: 1
-      /* STABLE */
-    }));
-  }
-};
-export {
-  T as default
-};