@shwfed/config 1.0.0

package/dist/runtime/composables/useOverlay.js

@@ -0,0 +1,268 @@
+import { Context, Deferred, Effect, Option } from "effect";
+import { reactive, ref } from "vue";
+function createResult(...args) {
+  if (args.length === 0) {
+    return Option.none();
+  }
+  return Option.some(args[0]);
+}
+function createOverlayRuntime() {
+  const definitions = reactive({});
+  const sessions = ref([]);
+  const alerts = ref([]);
+  function openAlert(input) {
+    return Effect.gen(function* () {
+      const deferred = yield* Deferred.make();
+      alerts.value.push({
+        alertId: crypto.randomUUID(),
+        open: true,
+        content: input.content,
+        icon: input.icon,
+        color: input.color,
+        deferred
+      });
+      return yield* Deferred.await(deferred);
+    });
+  }
+  function finalizeCloseAlert(alertId) {
+    const index = alerts.value.findIndex((alert2) => alert2.alertId === alertId);
+    if (index < 0) {
+      return;
+    }
+    const [alert] = alerts.value.splice(index, 1);
+    if (!alert) {
+      return;
+    }
+    Effect.runSync(Deferred.succeed(alert.deferred, alert.pendingResult ?? false));
+  }
+  function closeAlert(alertId, result, explicit = true) {
+    return Effect.sync(() => {
+      const alert = alerts.value.find((a) => a.alertId === alertId);
+      if (!alert) {
+        return;
+      }
+      if (explicit || alert.pendingResult === void 0) {
+        alert.pendingResult = result;
+      }
+      if (alert.open) {
+        alert.open = false;
+      }
+      if (!alert.finalizeScheduled) {
+        alert.finalizeScheduled = true;
+        queueMicrotask(() => finalizeCloseAlert(alertId));
+      }
+    });
+  }
+  function getDefinition(definitionId) {
+    return Reflect.get(definitions, definitionId);
+  }
+  function getSession(sessionId) {
+    return sessions.value.find((session) => session.sessionId === sessionId);
+  }
+  function removeSession(sessionId) {
+    const index = sessions.value.findIndex((session2) => session2.sessionId === sessionId);
+    if (index < 0) {
+      return void 0;
+    }
+    const [session] = sessions.value.splice(index, 1);
+    return session;
+  }
+  function finalizeClose(sessionId, result) {
+    const session = removeSession(sessionId);
+    if (!session) {
+      return;
+    }
+    Effect.runSync(Deferred.succeed(session.deferred, session.pendingResult ?? result ?? Option.none()));
+  }
+  function requestClose(sessionId, result) {
+    const session = getSession(sessionId);
+    if (!session || !session.open) {
+      return;
+    }
+    session.open = false;
+    session.pendingResult = result;
+  }
+  function closeDefinitionSessions(definitionId) {
+    const targetSessions = sessions.value.filter((session) => session.definitionId === definitionId).map((session) => session.sessionId);
+    for (const sessionId of targetSessions) {
+      finalizeClose(sessionId, Option.none());
+    }
+  }
+  function registerDefinition(definition) {
+    Reflect.set(definitions, definition.definitionId, definition);
+  }
+  function unregisterDefinition(definitionId, ownerId) {
+    const definition = getDefinition(definitionId);
+    if (!definition) {
+      return;
+    }
+    if (ownerId !== void 0 && definition.ownerId !== ownerId) {
+      return;
+    }
+    Reflect.deleteProperty(definitions, definitionId);
+    closeDefinitionSessions(definitionId);
+  }
+  function syncDefinitions(ownerId, nextDefinitions) {
+    const nextIds = nextDefinitions.map((definition) => definition.definitionId);
+    const currentIds = Object.values(definitions).filter((definition) => definition.ownerId === ownerId).map((definition) => definition.definitionId);
+    for (const definitionId of currentIds) {
+      if (!nextIds.includes(definitionId)) {
+        unregisterDefinition(definitionId, ownerId);
+      }
+    }
+    for (const definition of nextDefinitions) {
+      registerDefinition(definition);
+    }
+  }
+  function patchSession(sessionId, patch) {
+    const session = getSession(sessionId);
+    if (!session) {
+      return;
+    }
+    if (patch.shell) {
+      session.shell = {
+        ...session.shell,
+        ...patch.shell,
+        descriptionSrOnly: Reflect.has(patch.shell, "description") ? false : session.shell.descriptionSrOnly
+      };
+    }
+    if (patch.props) {
+      session.props = {
+        ...session.props,
+        ...patch.props
+      };
+    }
+  }
+  function createHandle(session) {
+    return {
+      patch: (patch) => Effect.sync(() => {
+        patchSession(session.sessionId, patch);
+      }),
+      close: (...args) => Effect.sync(() => {
+        requestClose(session.sessionId, createResult(...args));
+      }),
+      result: Deferred.await(session.deferred)
+    };
+  }
+  function open(definitionId, options) {
+    return Effect.map(Effect.acquireRelease(
+      Effect.gen(function* () {
+        const definition = getDefinition(definitionId);
+        if (!definition) {
+          return yield* Effect.fail({
+            _tag: "OverlayDefinitionNotFoundError",
+            definitionId
+          });
+        }
+        const definitionShell = definition.shell;
+        const descriptionSrOnly = options?.shell?.description === void 0 && definitionShell?.description === void 0;
+        const deferred = yield* Deferred.make();
+        const session = {
+          sessionId: crypto.randomUUID(),
+          definitionId,
+          open: true,
+          shell: {
+            title: options?.shell?.title ?? definitionShell?.title,
+            description: options?.shell?.description ?? definitionShell?.description,
+            descriptionSrOnly,
+            breakpoint: options?.shell?.breakpoint ?? definitionShell?.breakpoint,
+            trap: options?.shell?.trap ?? definitionShell?.trap,
+            width: options?.shell?.width ?? definitionShell?.width
+          },
+          props: {
+            ...options?.props
+          },
+          deferred
+        };
+        sessions.value.push(session);
+        return { handle: createHandle(session), sessionId: session.sessionId };
+      }),
+      ({ sessionId }) => Effect.sync(() => {
+        finalizeClose(sessionId, Option.none());
+      })
+    ), ({ handle }) => handle);
+  }
+  const runtime = {
+    get definitions() {
+      return definitions;
+    },
+    get sessions() {
+      return sessions.value;
+    },
+    get alerts() {
+      return alerts.value;
+    },
+    get topSession() {
+      return sessions.value.at(-1);
+    },
+    registerDefinition,
+    unregisterDefinition,
+    syncDefinitions,
+    isOpen: (sessionId) => getSession(sessionId)?.open === true,
+    open,
+    patch: (sessionId, patch) => Effect.sync(() => {
+      patchSession(sessionId, patch);
+    }),
+    close: (sessionId, ...args) => Effect.sync(() => {
+      requestClose(sessionId, createResult(...args));
+    }),
+    closeTop: () => Effect.sync(() => {
+      const topSession = sessions.value.at(-1);
+      if (topSession) {
+        requestClose(topSession.sessionId, Option.none());
+      }
+    }),
+    closeAll: () => Effect.sync(() => {
+      const sessionIds = sessions.value.map((session) => session.sessionId);
+      for (const sessionId of sessionIds) {
+        requestClose(sessionId, Option.none());
+      }
+    }),
+    openAlert,
+    closeAlert,
+    finalizeClose
+  };
+  return runtime;
+}
+const overlayRuntime = createOverlayRuntime();
+export function useOverlay() {
+  return overlayRuntime;
+}
+class ActionContext extends Context.Tag("shwfed/ActionContext")() {
+}
+export { ActionContext };
+export function openModal(options) {
+  return Effect.gen(function* () {
+    const { definitionId } = yield* ActionContext;
+    const handle = yield* overlayRuntime.open(definitionId, {
+      shell: {
+        title: options.title,
+        description: options.description,
+        trap: options.trap,
+        width: options.width
+      },
+      props: options.props
+    });
+    if (options.trap) {
+      const onBeforeUnload = (event) => {
+        event.preventDefault();
+      };
+      window.addEventListener("beforeunload", onBeforeUnload);
+      yield* Effect.addFinalizer(
+        () => Effect.sync(() => {
+          window.removeEventListener("beforeunload", onBeforeUnload);
+        })
+      );
+    }
+    return {
+      patch: (props) => handle.patch({ props }),
+      modal: handle.result
+    };
+  });
+}
+export function confirm(input) {
+  return overlayRuntime.openAlert(input);
+}
+export function reject(input) {
+  return Effect.map(overlayRuntime.openAlert(input), (confirmed) => !confirmed);
+}

package/dist/runtime/composables/useTranslateLocale.d.ts

@@ -0,0 +1,11 @@
+import type { LocaleValue } from '../share/locale.js';
+export type TargetLocale = 'ja' | 'en' | 'ko';
+export interface UseTranslateLocaleOptions {
+    readonly hint?: string;
+}
+export interface UseTranslateLocale {
+    readonly isTranslating: (target: TargetLocale) => boolean;
+    readonly canTranslate: (current: LocaleValue | undefined, target: TargetLocale) => boolean;
+    readonly translate: (current: LocaleValue, target: TargetLocale) => Promise<LocaleValue>;
+}
+export declare function useTranslateLocale(options?: UseTranslateLocaleOptions): UseTranslateLocale;

package/dist/runtime/composables/useTranslateLocale.js

@@ -0,0 +1,66 @@
+import { ref } from "vue";
+import { Schema } from "effect";
+import { useNuxtApp } from "#app";
+const SingleTranslation = Schema.Struct({
+  message: Schema.String
+}).annotations({ identifier: "LocaleSingleTranslation" });
+const TARGET_LANG_LABEL = {
+  ja: "Japanese",
+  en: "English",
+  ko: "Korean"
+};
+function buildSystem(target, hint) {
+  const surface = hint ?? "a UI label";
+  const lang = TARGET_LANG_LABEL[target];
+  return [
+    "You are a UI string translator for an enterprise admin console.",
+    `Translate the Chinese source into ${lang} for ${surface}.`,
+    "Output must be terse, idiomatic, and stylistically appropriate for the surface.",
+    "Preserve placeholders (e.g. {name}, %s), punctuation density, and casing conventions of the target language.",
+    "Never translate brand names, product names, or technical identifiers."
+  ].join(" ");
+}
+export function useTranslateLocale(options = {}) {
+  const { $ai } = useNuxtApp();
+  const inFlight = ref(/* @__PURE__ */ new Set());
+  function isTranslating(target) {
+    return inFlight.value.has(target);
+  }
+  function canTranslate(current, target) {
+    if (!$ai.available.value) return false;
+    if (!current) return false;
+    const zh = current.find((item) => item.locale === "zh");
+    if (!zh || !zh.message.trim()) return false;
+    const row = current.find((item) => item.locale === target);
+    if (!row) return false;
+    if (row.message.trim().length > 0) return false;
+    return true;
+  }
+  async function translate(current, target) {
+    const zh = current.find((item) => item.locale === "zh");
+    if (!zh || !zh.message.trim()) {
+      throw new Error("\u9700\u8981\u5148\u586B\u5199\u4E2D\u6587\u6587\u672C\u4F5C\u4E3A\u7FFB\u8BD1\u6765\u6E90");
+    }
+    const start = new Set(inFlight.value);
+    start.add(target);
+    inFlight.value = start;
+    try {
+      const result = await $ai.generateObject({
+        prompt: zh.message,
+        system: buildSystem(target, options.hint),
+        schema: SingleTranslation,
+        objectName: "translation"
+      });
+      return current.map((item) => {
+        if (item.locale !== target) return item;
+        if (item.message.trim().length > 0) return item;
+        return { locale: item.locale, message: result.message };
+      });
+    } finally {
+      const end = new Set(inFlight.value);
+      end.delete(target);
+      inFlight.value = end;
+    }
+  }
+  return { isTranslating, canTranslate, translate };
+}

package/dist/runtime/composables/useTreeDnd.d.ts

@@ -0,0 +1,52 @@
+import { type ComponentPublicInstance } from 'vue';
+import { type Instruction } from '@atlaskit/pragmatic-drag-and-drop-hitbox/tree-item';
+export type InstructionType = Instruction['type'];
+export interface DragSource {
+    kind: string;
+    id: string;
+    data: Record<string | symbol, unknown>;
+}
+export interface RowDropEvent {
+    source: DragSource;
+    target: {
+        kind: string;
+        id: string;
+    };
+    instruction: InstructionType;
+}
+export interface ZoneDropEvent {
+    source: DragSource;
+    zoneId: string;
+    data: Record<string, unknown>;
+}
+export interface RowConfig {
+    kind: string;
+    data?: Record<string, unknown>;
+    canDrop?: (source: DragSource) => boolean;
+    blockInstructions?: (source: DragSource) => InstructionType[];
+    resolveInstruction?: (params: {
+        input: {
+            clientX: number;
+            clientY: number;
+        };
+        element: Element;
+        source: DragSource;
+    }) => InstructionType | null;
+    dragHandle?: (element: HTMLElement) => HTMLElement | null;
+}
+export interface ZoneConfig {
+    data?: Record<string, unknown>;
+    canDrop?: (source: DragSource) => boolean;
+}
+export interface UseTreeDndOptions {
+    onRowDrop: (event: RowDropEvent) => void;
+    onZoneDrop?: (event: ZoneDropEvent) => void;
+}
+type TemplateRefEl = Element | ComponentPublicInstance | null;
+export declare function useTreeDnd(options: UseTreeDndOptions): {
+    rowRef: (id: string, config: RowConfig) => (el: TemplateRefEl) => void;
+    zoneRef: (id: string, config: ZoneConfig) => (el: TemplateRefEl) => void;
+    instructionFor: (id: string) => InstructionType | null;
+    isZoneActive: (id: string) => boolean;
+};
+export {};

package/dist/runtime/composables/useTreeDnd.js

@@ -0,0 +1,211 @@
+import { onBeforeUnmount, ref } from "vue";
+import { combine } from "@atlaskit/pragmatic-drag-and-drop/combine";
+import {
+  draggable,
+  dropTargetForElements
+} from "@atlaskit/pragmatic-drag-and-drop/element/adapter";
+import {
+  attachInstruction,
+  extractInstruction
+} from "@atlaskit/pragmatic-drag-and-drop-hitbox/tree-item";
+const CUSTOM_INSTRUCTION_KEY = "__shwfedCustomInstruction__";
+function toHTMLElement(el) {
+  return el instanceof HTMLElement ? el : null;
+}
+function readInstructionType(data) {
+  if (CUSTOM_INSTRUCTION_KEY in data) {
+    const v = data[CUSTOM_INSTRUCTION_KEY];
+    return typeof v === "string" ? v : null;
+  }
+  const inst = extractInstruction(data);
+  return inst && inst.type !== "instruction-blocked" ? inst.type : null;
+}
+function toSource(data) {
+  const kind = data.kind;
+  const id = data.id;
+  if (typeof kind !== "string" || typeof id !== "string") return null;
+  return { kind, id, data };
+}
+export function useTreeDnd(options) {
+  const rowInstruction = ref(null);
+  const activeZoneId = ref(null);
+  const rowRegs = /* @__PURE__ */ new Map();
+  const zoneRegs = /* @__PURE__ */ new Map();
+  const rowConfigs = /* @__PURE__ */ new Map();
+  const zoneConfigs = /* @__PURE__ */ new Map();
+  const rowRefCache = /* @__PURE__ */ new Map();
+  const zoneRefCache = /* @__PURE__ */ new Map();
+  function wireRow(key, id, el) {
+    return combine(
+      draggable({
+        element: el,
+        dragHandle: (() => {
+          const cfg = rowConfigs.get(key);
+          return cfg?.dragHandle?.(el) ?? void 0;
+        })(),
+        getInitialData: () => {
+          const cfg = rowConfigs.get(key);
+          return { kind: cfg?.kind ?? "row", id, ...cfg?.data ?? {} };
+        }
+      }),
+      dropTargetForElements({
+        element: el,
+        canDrop: ({ source }) => {
+          const src = toSource(source.data);
+          if (!src) return false;
+          const cfg = rowConfigs.get(key);
+          return cfg?.canDrop ? cfg.canDrop(src) : true;
+        },
+        getIsSticky: () => true,
+        getData: ({ input, element, source }) => {
+          const cfg = rowConfigs.get(key);
+          const src = toSource(source.data);
+          const block = src && cfg?.blockInstructions ? cfg.blockInstructions(src) : [];
+          const base = { kind: `${cfg?.kind ?? "row"}-target`, id };
+          if (cfg?.resolveInstruction && src) {
+            let type = cfg.resolveInstruction({ input, element, source: src });
+            if (type && block.includes(type)) type = null;
+            return { ...base, [CUSTOM_INSTRUCTION_KEY]: type };
+          }
+          return attachInstruction(
+            base,
+            {
+              input,
+              element,
+              currentLevel: 0,
+              indentPerLevel: 0,
+              mode: "standard",
+              block
+            }
+          );
+        },
+        onDrag: ({ self }) => {
+          const type = readInstructionType(self.data);
+          rowInstruction.value = type ? { id, type } : null;
+        },
+        onDragLeave: () => {
+          if (rowInstruction.value?.id === id) rowInstruction.value = null;
+        },
+        onDrop: ({ source, self }) => {
+          rowInstruction.value = null;
+          const type = readInstructionType(self.data);
+          if (!type) return;
+          const src = toSource(source.data);
+          if (!src) return;
+          const cfg = rowConfigs.get(key);
+          options.onRowDrop({
+            source: src,
+            target: { kind: cfg?.kind ?? "row", id },
+            instruction: type
+          });
+        }
+      })
+    );
+  }
+  function wireZone(id, el) {
+    return dropTargetForElements({
+      element: el,
+      canDrop: ({ source }) => {
+        const src = toSource(source.data);
+        if (!src) return false;
+        const cfg = zoneConfigs.get(id);
+        return cfg?.canDrop ? cfg.canDrop(src) : true;
+      },
+      getIsSticky: () => true,
+      getData: () => {
+        const cfg = zoneConfigs.get(id);
+        return { kind: "zone", id, ...cfg?.data ?? {} };
+      },
+      onDragEnter: () => {
+        activeZoneId.value = id;
+      },
+      onDragLeave: () => {
+        if (activeZoneId.value === id) activeZoneId.value = null;
+      },
+      onDrop: ({ source }) => {
+        activeZoneId.value = null;
+        const src = toSource(source.data);
+        if (!src) return;
+        const cfg = zoneConfigs.get(id);
+        options.onZoneDrop?.({
+          source: src,
+          zoneId: id,
+          data: cfg?.data ?? {}
+        });
+      }
+    });
+  }
+  function setRow(key, id, el) {
+    const existing = rowRegs.get(key);
+    if (!el) {
+      if (existing) {
+        existing.cleanup();
+        rowRegs.delete(key);
+        if (rowInstruction.value?.id === id) rowInstruction.value = null;
+      }
+      return;
+    }
+    if (existing && existing.el === el) return;
+    existing?.cleanup();
+    const cfg = rowConfigs.get(key);
+    if (!cfg) return;
+    rowRegs.set(key, { el, config: cfg, cleanup: wireRow(key, id, el) });
+  }
+  function setZone(id, el) {
+    const existing = zoneRegs.get(id);
+    if (!el) {
+      if (existing) {
+        existing.cleanup();
+        zoneRegs.delete(id);
+        if (activeZoneId.value === id) activeZoneId.value = null;
+      }
+      return;
+    }
+    if (existing && existing.el === el) return;
+    existing?.cleanup();
+    const cfg = zoneConfigs.get(id);
+    if (!cfg) return;
+    zoneRegs.set(id, { el, config: cfg, cleanup: wireZone(id, el) });
+  }
+  function rowRef(id, config) {
+    const key = `${config.kind}:${id}`;
+    rowConfigs.set(key, config);
+    let cached = rowRefCache.get(key);
+    if (!cached) {
+      cached = (el) => setRow(key, id, toHTMLElement(el));
+      rowRefCache.set(key, cached);
+    }
+    return cached;
+  }
+  function zoneRef(id, config) {
+    zoneConfigs.set(id, config);
+    let cached = zoneRefCache.get(id);
+    if (!cached) {
+      cached = (el) => setZone(id, toHTMLElement(el));
+      zoneRefCache.set(id, cached);
+    }
+    return cached;
+  }
+  function instructionFor(id) {
+    return rowInstruction.value?.id === id ? rowInstruction.value.type : null;
+  }
+  function isZoneActive(id) {
+    return activeZoneId.value === id;
+  }
+  onBeforeUnmount(() => {
+    for (const reg of rowRegs.values()) reg.cleanup();
+    for (const reg of zoneRegs.values()) reg.cleanup();
+    rowRegs.clear();
+    zoneRegs.clear();
+    rowConfigs.clear();
+    zoneConfigs.clear();
+    rowRefCache.clear();
+    zoneRefCache.clear();
+  });
+  return {
+    rowRef,
+    zoneRef,
+    instructionFor,
+    isZoneActive
+  };
+}

package/dist/runtime/middleware/token.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").RouteMiddleware;
+export default _default;

package/dist/runtime/middleware/token.js

@@ -0,0 +1,20 @@
+import { defineNuxtRouteMiddleware, navigateTo, useRuntimeConfig } from "#app";
+const TOKEN_PARAMS = ["token", "code", "access_token", "authorization"];
+export default defineNuxtRouteMiddleware((to, from) => {
+  if (from.name) return;
+  const queryKeys = Object.keys(to.query);
+  let matchedKey;
+  for (const param of TOKEN_PARAMS) {
+    matchedKey = queryKeys.find((k) => k.toLowerCase() === param);
+    if (matchedKey) break;
+  }
+  if (!matchedKey) return;
+  const value = to.query[matchedKey];
+  if (!value || Array.isArray(value)) return;
+  if (import.meta.client) {
+    const config = useRuntimeConfig().public.shwfed;
+    localStorage.setItem(config.ci.job, value);
+  }
+  const { [matchedKey]: _, ...remainingQuery } = to.query;
+  return navigateTo({ ...to, query: remainingQuery }, { replace: true });
+});

package/dist/runtime/plugins/ai/cel-prompt.d.ts

@@ -0,0 +1,11 @@
+import type { CELContext } from '../cel/context.js';
+import celSyntaxGuide from '../../vendor/cel-js/PROMPT.md?raw.js';
+export { celSyntaxGuide };
+export interface ComposeCelPromptInput {
+    readonly scope?: ReadonlyArray<{
+        readonly name: string;
+        readonly context: CELContext;
+    }>;
+    readonly task: string;
+}
+export declare function composeCelPrompt(input: ComposeCelPromptInput): string;

package/dist/runtime/plugins/ai/cel-prompt.js

@@ -0,0 +1,27 @@
+import celSyntaxGuide from "../../vendor/cel-js/PROMPT.md?raw";
+export { celSyntaxGuide };
+function renderScope(scope) {
+  const lines = [];
+  for (const { name, context } of scope) {
+    const entries = Object.entries(context);
+    if (entries.length === 0) continue;
+    lines.push(`### ${name}`);
+    lines.push("");
+    lines.push("| Variable | Type | Description |");
+    lines.push("|----------|------|-------------|");
+    for (const [varName, entry] of entries) {
+      const desc = (entry.description ?? entry.label).replace(/\|/g, "\\|").replace(/\n/g, " ");
+      lines.push(`| \`${varName}\` | \`${entry.type}\` | ${desc} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+export function composeCelPrompt(input) {
+  const parts = [celSyntaxGuide];
+  if (input.scope && input.scope.length > 0) {
+    parts.push("# Variables In Scope", "", renderScope(input.scope));
+  }
+  parts.push("# Task", "", input.task);
+  return parts.join("\n");
+}

package/dist/runtime/plugins/ai/gate.d.ts

@@ -0,0 +1 @@
+export declare function isByokAllowed(): boolean;

package/dist/runtime/plugins/ai/gate.js

@@ -0,0 +1,8 @@
+export function isByokAllowed() {
+  if (typeof window === "undefined") return false;
+  const h = window.location.hostname;
+  if (h === "localhost" || h === "127.0.0.1") return true;
+  if (h.startsWith("beta.")) return true;
+  if (h.includes(".beta.")) return true;
+  return false;
+}