underpost 2.6.2

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

@@ -0,0 +1,44 @@
+import { connectedScatterplotChart } from '../chart/connectedScatterplotChart.js';
+
+// https://takanori-fujiwara.github.io/d3-gallery-javascript/
+
+const D3Chart = {
+  Render: async function () {
+    setTimeout(async () => {
+      const driving = await d3.csv('/data/driving.csv', d3.autoType);
+
+      const button = d3.select('.chart-panel').append('div').append('button').attr('type', 'button').text('Replay');
+
+      const play = () => {
+        const chart = connectedScatterplotChart(driving, {
+          svgId: 'connected-scatterplot',
+          x: (d) => d.miles,
+          y: (d) => d.gas,
+          title: (d) => d.year,
+          orient: (d) => d.side,
+          yFormat: '.2f',
+          xLabel: 'Miles driven (per capita per year) →',
+          yLabel: '↑ Price of gas (per gallon, adjusted average $)',
+          width: 1000,
+          height: 720,
+          duration: 5000, // for the intro animation; 0 to disable
+        });
+        d3.select('#connected-scatterplot').remove();
+        d3.select('.chart-container').append(() => chart);
+      };
+
+      play();
+
+      // replay
+      button.on('click', () => {
+        play();
+      });
+    });
+    return html`
+      <div class="in chart-container"></div>
+      <div class="in chart-panel"></div>
+    `;
+  },
+};
+
+export { D3Chart };

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

@@ -0,0 +1,130 @@
+import { BtnIcon } from './BtnIcon.js';
+import { Css, dynamicCol, Themes } from './Css.js';
+import { DropDown } from './DropDown.js';
+import { Modal, renderMenuLabel, renderViewTitle } from './Modal.js';
+import { listenQueryPathInstance, setQueryPath } from './Router.js';
+import { Translate } from './Translate.js';
+import { getProxyPath, getQueryParams, htmls, s } from './VanillaJs.js';
+
+// https://mintlify.com/docs/quickstart
+
+const Docs = {
+  RenderModal: async function (type, modalOptions) {
+    const docData = this.Data.find((d) => d.type === type);
+    const ModalId = `modal-docs-${docData.type}`;
+    const { barConfig } = await Themes[Css.currentTheme]();
+    barConfig.buttons.close.onClick = () => {
+      setQueryPath({ path: 'docs' });
+      Modal.removeModal(ModalId);
+    };
+    await Modal.Render({
+      barConfig,
+      title: renderViewTitle(docData),
+      id: ModalId,
+      html: async () => {
+        return html`
+          <iframe class="in iframe-${ModalId}" style="width: 100%; border: none;" src="${docData.url()}"> </iframe>
+        `;
+      },
+      maximize: true,
+      mode: 'view',
+      slideMenu: 'modal-menu',
+      observer: true,
+      barMode: 'top-bottom-bar',
+      ...modalOptions,
+    });
+    Modal.Data[ModalId].onObserverListener[ModalId] = () => {
+      if (s(`.iframe-${ModalId}`))
+        s(`.iframe-${ModalId}`).style.height = `${s(`.${ModalId}`).offsetHeight - Modal.headerTitleHeight}px`;
+    };
+    Modal.Data[ModalId].onObserverListener[ModalId]();
+  },
+  Data: [
+    {
+      type: 'src',
+      icon: html`<i class="fa-brands fa-osi"></i>`,
+      text: 'Source Docs',
+      url: function () {
+        return `${getProxyPath()}docs/engine/2.6.2`;
+      },
+    },
+    {
+      type: 'api',
+      icon: html`<i class="fa-solid fa-arrows-turn-to-dots"></i>`,
+      text: `Api Docs`,
+      url: function () {
+        return `${getProxyPath()}api-docs`;
+      },
+    },
+    {
+      type: 'repo',
+      icon: html`<i class="fab fa-github"></i>`,
+      text: `Last Release`,
+      url: function () {
+        return `https://github.com/underpostnet/engine/`;
+      },
+    },
+  ],
+  Init: async function (options) {
+    const { idModal } = options;
+    setTimeout(() => {
+      s(`.btn-docs-src`).onclick = async () => {
+        setTimeout(() => setQueryPath({ path: 'docs', queryPath: 'src' }));
+        await this.RenderModal('src', options.modalOptions);
+      };
+      s(`.btn-docs-api`).onclick = async () => {
+        setTimeout(() => setQueryPath({ path: 'docs', queryPath: 'api' }));
+        await this.RenderModal('api', options.modalOptions);
+      };
+      s(`.btn-docs-repo`).onclick = () => {
+        const docData = this.Data.find((d) => d.type === 'repo');
+        location.href = docData.url();
+      };
+      // if (!getQueryParams().p) s(`.btn-docs-src`).click();
+      listenQueryPathInstance({
+        id: options.idModal,
+        routeId: 'docs',
+        event: (path) => {
+          if (s(`.btn-docs-${path}`)) s(`.btn-docs-${path}`).click();
+        },
+      });
+    });
+    let docMenuRender = '';
+    for (const docData of this.Data) {
+      docMenuRender += html` <div class="in">
+        ${await BtnIcon.Render({
+          class: `inl section-mp btn-custom btn-docs-${docData.type}`,
+          label: html`${docData.icon} ${docData.text}`,
+        })}
+      </div>`;
+    }
+    return html` <div class="in section-mp">${docMenuRender}</div>`;
+    return html` <div class="in section-mp">
+      ${await DropDown.Render({
+        id: 'dropdown-docs',
+        disableClose: true,
+        disableSelectLabel: true,
+        disableSelectOptionsLabel: true,
+        disableSearchBox: true,
+        open: true,
+        lastSelectClass: 'hover-active',
+        label: renderMenuLabel({
+          icon: html`<i class="fas fa-book"></i>`,
+          text: html`${Translate.Render('docs')}`,
+        }),
+        containerClass: '',
+        data: this.Data.map((docTypeData) => {
+          return {
+            display: docTypeData.label,
+            value: docTypeData.type,
+            onClick: async () => {
+              console.warn(this.viewUrl[docTypeData.type]());
+            },
+          };
+        }),
+      })}
+    </div>`;
+  },
+};
+
+export { Docs };

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

@@ -0,0 +1,164 @@
+import { getId, newInstance } from './CommonJs.js';
+import { Input } from './Input.js';
+import { ToggleSwitch } from './ToggleSwitch.js';
+import { Translate } from './Translate.js';
+import { s, htmls } from './VanillaJs.js';
+
+const DropDown = {
+  Tokens: {},
+  Render: async function (options) {
+    const id = options.id ? options.id : getId(this.Tokens, 'dropdown-');
+    this.Tokens[id] = { onClickEvents: {}, lastSelectValue: undefined };
+
+    options.data.push({
+      value: 'reset',
+      display: html`<i class="fa-solid fa-broom"></i> ${Translate.Render('clear')}`,
+      onClick: () => {
+        console.log('DropDown onClick', this.value);
+        if (options && options.resetOnClick) options.resetOnClick();
+        this.Tokens[id].value = undefined;
+      },
+    });
+
+    if (!(options && options.disableClose))
+      options.data.push({
+        value: 'close',
+        display: html`<i class="fa-solid fa-xmark"></i> ${Translate.Render('close')}`,
+        onClick: function () {
+          console.log('DropDown onClick', this.value);
+        },
+      });
+
+    const switchOptionsPanel = () => {
+      if (Array.from(s(`.dropdown-option-${id}`).classList).includes('hide'))
+        s(`.dropdown-option-${id}`).classList.remove('hide');
+      else s(`.dropdown-option-${id}`).classList.add('hide');
+    };
+
+    setTimeout(() => {
+      if (options.type === 'checkbox')
+        options.data.map((optionData) => {
+          const indexValue = options.data.findIndex((t) => optionData.checked && t.value === optionData.value);
+          if (indexValue > -1) setTimeout(() => s(`.dropdown-option-${id}-${indexValue}`).click());
+        });
+      else {
+        const indexValue = options.data.findIndex((t) => t.value === options.value);
+        if (indexValue > -1) setTimeout(() => s(`.dropdown-option-${id}-${indexValue}`).click());
+      }
+
+      s(`.dropdown-label-${id}`).onclick = switchOptionsPanel;
+      s(`.dropdown-current-${id}`).onclick = switchOptionsPanel;
+      if (options && options.open) switchOptionsPanel();
+    });
+
+    let render = '';
+    let index = -1;
+    for (const optionData of options.data) {
+      index++;
+      const i = index;
+      const valueDisplay = optionData.value.trim().replaceAll(' ', '-');
+      setTimeout(() => {
+        const onclick = (e) => {
+          if (options && options.lastSelectClass && s(`.dropdown-option-${this.Tokens[id].lastSelectValue}`)) {
+            s(`.dropdown-option-${this.Tokens[id].lastSelectValue}`).classList.remove(options.lastSelectClass);
+          }
+          this.Tokens[id].lastSelectValue = valueDisplay;
+          if (options && options.lastSelectClass && s(`.dropdown-option-${this.Tokens[id].lastSelectValue}`)) {
+            s(`.dropdown-option-${this.Tokens[id].lastSelectValue}`).classList.add(options.lastSelectClass);
+          }
+
+          if (
+            !(options && options.disableClose) &&
+            (options.type !== 'checkbox' || optionData.value === 'close' || optionData.value === 'reset')
+          )
+            s(`.dropdown-option-${id}`).classList.add('hide');
+
+          if (options.type === 'checkbox' && ToggleSwitch.Tokens[`checkbox-role-${valueDisplay}`])
+            ToggleSwitch.Tokens[`checkbox-role-${valueDisplay}`].click();
+          if (optionData.value !== 'close') {
+            if (optionData.value !== 'reset')
+              htmls(
+                `.dropdown-current-${id}`,
+                options.type === 'checkbox'
+                  ? options.data
+                      .filter((d) => d.checked)
+                      .map((v, i, a) => `${v.display}${i < a.length - 1 ? ',' : ''}`)
+                      .join('')
+                  : optionData.display,
+              );
+            else htmls(`.dropdown-current-${id}`, '');
+
+            this.Tokens[id].value =
+              options.type === 'checkbox' ? options.data.filter((d) => d.checked).map((d) => d.data) : optionData.data;
+
+            console.warn('current value dropdown id:' + id, this.Tokens[id].value);
+
+            s(`.${id}`).value = this.Tokens[id].value;
+
+            optionData.onClick(e);
+          }
+        };
+
+        this.Tokens[id].onClickEvents[`dropdown-option-${id}-${i}`] = onclick;
+        this.Tokens[id].onClickEvents[`dropdown-option-${id}-${valueDisplay}`] = onclick;
+        this.Tokens[id].onClickEvents[`dropdown-option-${valueDisplay}`] = onclick;
+
+        s(`.dropdown-option-${id}-${i}`).onclick = onclick;
+      });
+      render += html`
+        <div
+          class="in dropdown-option dropdown-option-${id}-${i} dropdown-option-${id}-${valueDisplay} dropdown-option-${valueDisplay} ${valueDisplay ===
+            'reset' &&
+          options &&
+          !(options.resetOption === true)
+            ? 'hide'
+            : ''}"
+        >
+          ${options.type === 'checkbox' && optionData.value !== 'close' && optionData.value !== 'reset'
+            ? html`
+                ${await ToggleSwitch.Render({
+                  id: `checkbox-role-${valueDisplay}`,
+                  type: 'checkbox',
+                  disabledOnClick: true,
+                  checked: optionData.checked,
+                  on: {
+                    unchecked: () => {
+                      optionData.checked = false;
+                    },
+                    checked: () => {
+                      optionData.checked = true;
+                    },
+                  },
+                })}
+              `
+            : ''}${optionData.display}
+        </div>
+      `;
+    }
+    return html`
+      <div class="inl dropdown-container ${id} ${options?.containerClass ? options.containerClass : ''}">
+        <div class="in dropdown-option dropdown-label-${id} ${options && options.disableSelectLabel ? 'hide' : ''}">
+          <i class="fa-solid fa-caret-down"> </i> ${options.label}
+        </div>
+        <div
+          class="in dropdown-option dropdown-current-${id} ${options && options.disableSelectOptionsLabel
+            ? 'hide'
+            : ''}"
+        ></div>
+        <div class="in dropdown-option-${id} hide">
+          <div class="in dropdown-option ${options && options.disableSearchBox ? 'hide' : ''}">
+            ${await Input.Render({
+              id: `search-box-${id}`,
+              label: html`<i class="fa-solid fa-magnifying-glass"></i> ${Translate.Render('search')}`,
+              containerClass: 'in',
+              placeholder: true,
+            })}
+          </div>
+          ${render}
+        </div>
+      </div>
+    `;
+  },
+};
+
+export { DropDown };

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

@@ -0,0 +1,54 @@
+import { LoadingAnimation } from '../core/LoadingAnimation.js';
+import { loggerFactory } from '../core/Logger.js';
+import { cssEffect } from './Css.js';
+import { NotificationManager } from './NotificationManager.js';
+import { s } from './VanillaJs.js';
+
+const logger = loggerFactory(import.meta);
+
+const EventsUI = {
+  on: (id = '', logic = function (e) {}, type = 'onclick', options = {}) => {
+    const { loadingContainer, disableSpinner } = options;
+    if (!s(id)) return;
+    let complete = true;
+    s(id)[type] = async function (e) {
+      cssEffect(id, e);
+      if (complete) {
+        complete = false;
+        if (!disableSpinner) await LoadingAnimation.spinner.play(loadingContainer ? loadingContainer : id);
+        await LoadingAnimation.bar.play(id);
+        try {
+          await logic(e);
+        } catch (error) {
+          logger.error(error);
+          NotificationManager.Push({
+            status: 'error',
+            html: error?.message ? error.message : error ? error : 'Event error',
+          });
+        }
+        LoadingAnimation.bar.stop(id);
+        if (!disableSpinner) await LoadingAnimation.spinner.stop(loadingContainer ? loadingContainer : id);
+        complete = true;
+        return;
+      }
+      if (e && e.preventDefault) e.preventDefault();
+      logger.warn('in process', id);
+    };
+  },
+  onClick: async function (
+    id = '',
+    logic = async function (e) {},
+    options = { disableSpinner: false, loadingContainer: '' },
+  ) {
+    return await this.on(id, logic, 'onclick', options);
+  },
+  onChange: async function (
+    id = '',
+    logic = async function (e) {},
+    options = { disableSpinner: false, loadingContainer: '' },
+  ) {
+    return await this.on(id, logic, 'onchange', options);
+  },
+};
+
+export { EventsUI };