@jskit-ai/shell-web 0.1.4

package/src/client/components/useShellLayout.js

@@ -0,0 +1,93 @@
+import { computed, ref } from "vue";
+import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
+
+const DEFAULT_ACTION_FALLBACK = Object.freeze({
+  label: "",
+  to: "",
+  variant: "text",
+  color: "secondary"
+});
+
+const DEFAULT_MENU_FALLBACK = Object.freeze({
+  label: "",
+  to: "/",
+  icon: "$menu"
+});
+
+function normalizeAction(action, fallback) {
+  const source = normalizeObject(action);
+  const fallbackSource = normalizeObject(fallback);
+  const label = String(source.label || fallbackSource.label || "").trim();
+  if (!label) {
+    return null;
+  }
+
+  return {
+    label,
+    to: String(source.to || fallbackSource.to || "").trim(),
+    variant: String(source.variant || fallbackSource.variant || "text").trim(),
+    color: String(source.color || fallbackSource.color || "secondary").trim()
+  };
+}
+
+function normalizeMenuItem(item, fallback) {
+  const source = normalizeObject(item);
+  const fallbackSource = normalizeObject(fallback);
+  const label = String(source.label || fallbackSource.label || "").trim();
+  if (!label) {
+    return null;
+  }
+
+  return {
+    label,
+    to: String(source.to || fallbackSource.to || "").trim() || "/",
+    icon: String(source.icon || fallbackSource.icon || "$menu").trim() || "$menu"
+  };
+}
+
+function normalizeActionList(actions) {
+  const source = Array.isArray(actions) ? actions : [];
+  return source
+    .map((item) => normalizeAction(item, DEFAULT_ACTION_FALLBACK))
+    .filter(Boolean);
+}
+
+function normalizeMenuList(items) {
+  const source = Array.isArray(items) ? items : [];
+  return source
+    .map((item) => normalizeMenuItem(item, DEFAULT_MENU_FALLBACK))
+    .filter(Boolean);
+}
+
+function useShellLayout({ topLeftActions, topRightActions, menuItems } = {}) {
+  const drawerOpen = ref(true);
+
+  const resolvedTopLeftActions = computed(() => {
+    const source = topLeftActions?.value;
+    return normalizeActionList(source);
+  });
+
+  const resolvedTopRightActions = computed(() => {
+    const source = topRightActions?.value;
+    return normalizeActionList(source);
+  });
+
+  const resolvedMenuItems = computed(() => {
+    const source = menuItems?.value;
+    return normalizeMenuList(source);
+  });
+
+  function toggleDrawer() {
+    drawerOpen.value = !drawerOpen.value;
+  }
+
+  return {
+    drawerOpen,
+    resolvedTopLeftActions,
+    resolvedTopRightActions,
+    resolvedMenuItems,
+    toggleDrawer
+  };
+}
+
+export { useShellLayout };

package/src/client/error/index.js

@@ -0,0 +1,2 @@
+export { createDefaultErrorPolicy } from "./policy.js";
+export { useShellWebErrorRuntime } from "./inject.js";

package/src/client/error/inject.js

@@ -0,0 +1,142 @@
+import {
+  inject,
+  onBeforeUnmount,
+  onMounted,
+  shallowRef
+} from "vue";
+import {
+  SHELL_WEB_ERROR_RUNTIME_INJECTION_KEY,
+  SHELL_WEB_ERROR_PRESENTATION_STORE_INJECTION_KEY
+} from "./tokens.js";
+
+const EMPTY_PRESENTATION_STATE = Object.freeze({
+  revision: 0,
+  channels: Object.freeze({
+    snackbar: Object.freeze([]),
+    banner: Object.freeze([]),
+    dialog: Object.freeze([])
+  })
+});
+
+const EMPTY_ERROR_RUNTIME = Object.freeze({
+  report() {
+    return Object.freeze({
+      skipped: true,
+      reason: "unavailable"
+    });
+  },
+  dismiss() {
+    return 0;
+  },
+  configure() {
+    return Object.freeze({
+      presenterIds: Object.freeze([]),
+      appDefaultPresenterId: "",
+      moduleDefaultPresenterId: "",
+      resolvedDefaultPresenterId: ""
+    });
+  },
+  registerPresenter() {
+    throw new Error("Shell web error runtime is not available.");
+  },
+  registerPresenters() {
+    throw new Error("Shell web error runtime is not available.");
+  },
+  setPolicy() {
+    throw new Error("Shell web error runtime is not available.");
+  },
+  setAppDefaultPresenterId() {
+    throw new Error("Shell web error runtime is not available.");
+  },
+  assertBootReady() {
+    throw new Error("Shell web error runtime is not available.");
+  },
+  getSnapshot() {
+    return Object.freeze({
+      presenterIds: Object.freeze([]),
+      appDefaultPresenterId: "",
+      moduleDefaultPresenterId: "",
+      resolvedDefaultPresenterId: ""
+    });
+  },
+  subscribe() {
+    return () => {};
+  }
+});
+
+const EMPTY_PRESENTATION_STORE = Object.freeze({
+  getState() {
+    return EMPTY_PRESENTATION_STATE;
+  },
+  subscribe() {
+    return () => {};
+  },
+  present() {
+    throw new Error("Shell web error presentation store is not available.");
+  },
+  dismiss() {
+    return 0;
+  },
+  clear() {
+    return 0;
+  }
+});
+
+function useShellWebErrorRuntime({ required = false } = {}) {
+  const runtime = inject(SHELL_WEB_ERROR_RUNTIME_INJECTION_KEY, null);
+  if (runtime && typeof runtime.report === "function") {
+    return runtime;
+  }
+
+  if (required) {
+    throw new Error("Shell web error runtime is not available in Vue injection context.");
+  }
+
+  return EMPTY_ERROR_RUNTIME;
+}
+
+function useShellWebErrorPresentationStore({ required = false } = {}) {
+  const store = inject(SHELL_WEB_ERROR_PRESENTATION_STORE_INJECTION_KEY, null);
+  if (store && typeof store.getState === "function" && typeof store.subscribe === "function") {
+    return store;
+  }
+
+  if (required) {
+    throw new Error("Shell web error presentation store is not available in Vue injection context.");
+  }
+
+  return EMPTY_PRESENTATION_STORE;
+}
+
+function useShellWebErrorPresentationState({ required = false } = {}) {
+  const store = useShellWebErrorPresentationStore({ required });
+  const state = shallowRef(store.getState());
+  let unsubscribe = null;
+
+  onMounted(() => {
+    unsubscribe = store.subscribe((nextState) => {
+      state.value = nextState;
+    });
+  });
+
+  onBeforeUnmount(() => {
+    if (typeof unsubscribe === "function") {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  });
+
+  return Object.freeze({
+    state,
+    store
+  });
+}
+
+export {
+  EMPTY_ERROR_RUNTIME,
+  EMPTY_PRESENTATION_STORE,
+  EMPTY_PRESENTATION_STATE,
+  useShellWebErrorRuntime,
+  useShellWebErrorPresentationStore,
+  useShellWebErrorPresentationState
+};

package/src/client/error/normalize.js

@@ -0,0 +1,75 @@
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
+
+const ERROR_CHANNELS = Object.freeze(["snackbar", "banner", "dialog", "silent"]);
+const ERROR_SEVERITIES = Object.freeze(["info", "success", "warning", "error", "critical"]);
+
+function normalizeText(value, fallback = "") {
+  const normalized = String(value || "").trim();
+  if (normalized) {
+    return normalized;
+  }
+  return String(fallback || "").trim();
+}
+
+function normalizeChannel(value, fallback = "") {
+  const normalized = normalizeText(value).toLowerCase();
+  if (ERROR_CHANNELS.includes(normalized)) {
+    return normalized;
+  }
+  return normalizeText(fallback).toLowerCase();
+}
+
+function normalizeSeverity(value, fallback = "error") {
+  const normalized = normalizeText(value).toLowerCase();
+  if (ERROR_SEVERITIES.includes(normalized)) {
+    return normalized;
+  }
+
+  const normalizedFallback = normalizeText(fallback).toLowerCase();
+  if (ERROR_SEVERITIES.includes(normalizedFallback)) {
+    return normalizedFallback;
+  }
+
+  return "error";
+}
+
+function normalizeNonNegativeInteger(value, fallback = 0) {
+  const numericValue = Number(value);
+  if (!Number.isFinite(numericValue)) {
+    return Math.max(0, Number(fallback || 0));
+  }
+  if (numericValue < 0) {
+    return 0;
+  }
+  return Math.trunc(numericValue);
+}
+
+function normalizeAction(value) {
+  const source = isRecord(value) ? value : null;
+  if (!source) {
+    return null;
+  }
+
+  const label = normalizeText(source.label);
+  const handler = typeof source.handler === "function" ? source.handler : null;
+  if (!label || !handler) {
+    return null;
+  }
+
+  return Object.freeze({
+    label,
+    handler,
+    dismissOnRun: source.dismissOnRun !== false
+  });
+}
+
+export {
+  ERROR_CHANNELS,
+  ERROR_SEVERITIES,
+  isRecord,
+  normalizeText,
+  normalizeChannel,
+  normalizeSeverity,
+  normalizeNonNegativeInteger,
+  normalizeAction
+};

package/src/client/error/policy.js

@@ -0,0 +1,50 @@
+import {
+  normalizeAction,
+  normalizeChannel,
+  normalizeSeverity,
+  normalizeText
+} from "./normalize.js";
+
+function createDefaultErrorPolicy({
+  defaultChannel = "snackbar",
+  unauthorizedChannel = "banner",
+  serverErrorChannel = "dialog",
+  defaultSeverity = "error"
+} = {}) {
+  const normalizedDefaultChannel = normalizeChannel(defaultChannel, "snackbar") || "snackbar";
+  const normalizedUnauthorizedChannel = normalizeChannel(unauthorizedChannel, "banner") || "banner";
+  const normalizedServerErrorChannel = normalizeChannel(serverErrorChannel, "dialog") || "dialog";
+  const normalizedDefaultSeverity = normalizeSeverity(defaultSeverity, "error");
+
+  return function defaultErrorPolicy(event = {}) {
+    const status = Number(event.status || 0);
+    const explicitChannel = normalizeChannel(event.channel);
+
+    let channel = explicitChannel;
+    if (!channel) {
+      if (event.blocking === true || status >= 500) {
+        channel = normalizedServerErrorChannel;
+      } else if (status === 401 || status === 403) {
+        channel = normalizedUnauthorizedChannel;
+      } else {
+        channel = normalizedDefaultChannel;
+      }
+    }
+
+    const message = normalizeText(event.userMessage || event.message, "Request failed.");
+
+    return Object.freeze({
+      channel,
+      message,
+      severity: normalizeSeverity(event.severity, normalizedDefaultSeverity),
+      presenterId: normalizeText(event.presenterId),
+      action: normalizeAction(event.action),
+      persist: channel !== "snackbar",
+      dedupeKey: normalizeText(event.dedupeKey)
+    });
+  };
+}
+
+export {
+  createDefaultErrorPolicy
+};

package/src/client/error/presenters.js

@@ -0,0 +1,89 @@
+import { normalizeText } from "./normalize.js";
+
+const MATERIAL_SNACKBAR_PRESENTER_ID = "material.snackbar";
+const MATERIAL_BANNER_PRESENTER_ID = "material.banner";
+const MATERIAL_DIALOG_PRESENTER_ID = "material.dialog";
+const MODULE_DEFAULT_PRESENTER_ID = MATERIAL_SNACKBAR_PRESENTER_ID;
+
+function createStoreBackedPresenter({
+  id,
+  channel,
+  store,
+  defaultPersist = false
+} = {}) {
+  const normalizedId = normalizeText(id);
+  const normalizedChannel = normalizeText(channel).toLowerCase();
+  if (!normalizedId) {
+    throw new Error("createStoreBackedPresenter requires id.");
+  }
+  if (!normalizedChannel) {
+    throw new Error(`createStoreBackedPresenter("${normalizedId}") requires channel.`);
+  }
+  if (!store || typeof store.present !== "function" || typeof store.dismiss !== "function") {
+    throw new Error(`createStoreBackedPresenter("${normalizedId}") requires a presentation store.`);
+  }
+
+  return Object.freeze({
+    id: normalizedId,
+    supports(requestedChannel = "") {
+      return String(requestedChannel || "").trim().toLowerCase() === normalizedChannel;
+    },
+    present(payload = {}) {
+      return store.present(normalizedChannel, {
+        ...payload,
+        persist: typeof payload.persist === "boolean" ? payload.persist : defaultPersist,
+        presenterId: normalizedId
+      });
+    },
+    dismiss(presentationId = "") {
+      return store.dismiss(normalizedChannel, String(presentationId || ""));
+    }
+  });
+}
+
+function createMaterialSnackbarPresenter({ store } = {}) {
+  return createStoreBackedPresenter({
+    id: MATERIAL_SNACKBAR_PRESENTER_ID,
+    channel: "snackbar",
+    store,
+    defaultPersist: false
+  });
+}
+
+function createMaterialBannerPresenter({ store } = {}) {
+  return createStoreBackedPresenter({
+    id: MATERIAL_BANNER_PRESENTER_ID,
+    channel: "banner",
+    store,
+    defaultPersist: true
+  });
+}
+
+function createMaterialDialogPresenter({ store } = {}) {
+  return createStoreBackedPresenter({
+    id: MATERIAL_DIALOG_PRESENTER_ID,
+    channel: "dialog",
+    store,
+    defaultPersist: true
+  });
+}
+
+function createDefaultMaterialErrorPresenters({ store } = {}) {
+  return Object.freeze([
+    createMaterialSnackbarPresenter({ store }),
+    createMaterialBannerPresenter({ store }),
+    createMaterialDialogPresenter({ store })
+  ]);
+}
+
+export {
+  MATERIAL_SNACKBAR_PRESENTER_ID,
+  MATERIAL_BANNER_PRESENTER_ID,
+  MATERIAL_DIALOG_PRESENTER_ID,
+  MODULE_DEFAULT_PRESENTER_ID,
+  createStoreBackedPresenter,
+  createMaterialSnackbarPresenter,
+  createMaterialBannerPresenter,
+  createMaterialDialogPresenter,
+  createDefaultMaterialErrorPresenters
+};