mirror of
https://github.com/Elysola/WebHooker.git
synced 2026-11-20 17:13:49 +00:00
Give each target labeled fields and a compact platform header, widen the filter workspace, and align fragment controls. Scroll failed validation into view when the footer is far from the affected section.
638 lines
20 KiB
Vue
638 lines
20 KiB
Vue
<script setup lang="ts">
|
|
import { computed, nextTick, reactive, ref, watch } from "vue";
|
|
import { Trash2 } from "lucide-vue-next";
|
|
import type { Filter, FilterNode, NamedFragment, Route, RouteTarget, RouteTemplate } from "~/types";
|
|
import { FRAGMENT_PRESETS, ROUTE_TEMPLATES } from "~/types";
|
|
import type { NodeForm } from "~/composables/useFilterNode";
|
|
import {
|
|
blankLeafForm,
|
|
blankNode,
|
|
nodeToForm,
|
|
nodeFormToRouteFilters,
|
|
formToNode,
|
|
} from "~/composables/useFilterNode";
|
|
|
|
interface TargetForm {
|
|
platform: "discord" | "telegram" | "feishu";
|
|
channelId: string;
|
|
threadId: string;
|
|
chatId: string;
|
|
topicId: string;
|
|
}
|
|
|
|
const props = withDefaults(
|
|
defineProps<{ open: boolean; route: Route | null; saving: boolean; groupId?: string | null }>(),
|
|
{ groupId: null },
|
|
);
|
|
|
|
const emit = defineEmits<{ (e: "close"): void; (e: "save", route: Route): void }>();
|
|
|
|
const { t } = useI18n();
|
|
const { confirm } = useConfirm();
|
|
|
|
const isEdit = computed(() => props.route != null);
|
|
const discordRoles = computed({
|
|
get: () =>
|
|
form.discordRolesText
|
|
.split(",")
|
|
.map((role) => role.trim())
|
|
.filter(Boolean),
|
|
set: (roles: string[]) => {
|
|
form.discordRolesText = roles.join(", ");
|
|
},
|
|
});
|
|
const bodyEl = ref<HTMLFormElement | null>(null);
|
|
const filterError = ref("");
|
|
const targetError = ref("");
|
|
const formError = ref("");
|
|
|
|
const blankTarget = (): TargetForm => ({
|
|
platform: "discord",
|
|
channelId: "",
|
|
threadId: "",
|
|
chatId: "",
|
|
topicId: "",
|
|
});
|
|
|
|
const form = reactive({
|
|
id: "",
|
|
name: "",
|
|
enabled: true,
|
|
fallback: false,
|
|
stop: false,
|
|
discordRolesText: "",
|
|
targets: [] as TargetForm[],
|
|
});
|
|
|
|
const root = ref<NodeForm>(blankNode("all"));
|
|
|
|
const { fragments, load: loadFragments, save: saveFragments } = useFragmentsApi();
|
|
const fragmentName = ref("");
|
|
const fragmentError = ref("");
|
|
|
|
const testPayload = ref("");
|
|
const testEvent = ref("");
|
|
const testResult = ref<{ matched: boolean; explanation: string } | null>(null);
|
|
const testError = ref("");
|
|
const testing = ref(false);
|
|
|
|
function applyTemplate(tmpl: RouteTemplate): void {
|
|
form.id = tmpl.id;
|
|
form.name = t(tmpl.nameKey);
|
|
form.targets = [blankTarget()];
|
|
root.value = tmpl.filters.length ? nodeToForm({ all: tmpl.filters }) : blankNode("all");
|
|
}
|
|
|
|
function addTarget(): void {
|
|
form.targets.push(blankTarget());
|
|
}
|
|
|
|
async function removeTarget(target: TargetForm): Promise<void> {
|
|
const filled = [target.channelId, target.threadId, target.chatId, target.topicId].some((v) =>
|
|
v.trim(),
|
|
);
|
|
if (filled) {
|
|
const n = form.targets.indexOf(target) + 1;
|
|
if (!(await confirm({ title: t("confirm.removeTarget", { n }) }))) return;
|
|
}
|
|
const index = form.targets.indexOf(target);
|
|
if (index >= 0) form.targets.splice(index, 1);
|
|
}
|
|
|
|
function validateNode(nf: NodeForm): string | null {
|
|
if (nf.kind === "leaf") {
|
|
if (nf.leaf.type === "field" && !nf.leaf.path.trim()) return t("routeEditor.errPath");
|
|
if (nf.leaf.op !== "exists" && nf.leaf.values.every((v) => !v.trim()))
|
|
return t("routeEditor.errValues");
|
|
return null;
|
|
}
|
|
if (nf.kind === "all" || nf.kind === "any") {
|
|
if (nf.children.length === 0) return t("routeEditor.errGroupEmpty");
|
|
for (const c of nf.children) {
|
|
const err = validateNode(c);
|
|
if (err) return err;
|
|
}
|
|
return null;
|
|
}
|
|
if (nf.child) return validateNode(nf.child);
|
|
return t("routeEditor.errGroupEmpty");
|
|
}
|
|
|
|
function collect(): Route | null {
|
|
filterError.value = "";
|
|
targetError.value = "";
|
|
formError.value = "";
|
|
|
|
let filters: Filter[] = [];
|
|
let ast: FilterNode | undefined;
|
|
if (!form.fallback) {
|
|
const err = validateNode(root.value);
|
|
if (err) {
|
|
filterError.value = err;
|
|
return null;
|
|
}
|
|
const res = nodeFormToRouteFilters(root.value);
|
|
filters = res.filters;
|
|
ast = res.ast;
|
|
} else {
|
|
const res = nodeFormToRouteFilters(root.value);
|
|
const has = res.filters.length > 0 || res.ast !== undefined;
|
|
if (has) {
|
|
const err = validateNode(root.value);
|
|
if (err) {
|
|
filterError.value = err;
|
|
return null;
|
|
}
|
|
filters = res.filters;
|
|
ast = res.ast;
|
|
}
|
|
}
|
|
|
|
const targets: RouteTarget[] = [];
|
|
for (const tg of form.targets) {
|
|
if (tg.platform === "telegram") {
|
|
const chatId = tg.chatId.trim();
|
|
if (!chatId) continue;
|
|
targets.push({ platform: "telegram", chatId, topicId: tg.topicId.trim() || undefined });
|
|
} else if (tg.platform === "feishu") {
|
|
const chatId = tg.chatId.trim();
|
|
if (!chatId) continue;
|
|
targets.push({ platform: "feishu", chatId });
|
|
} else {
|
|
const channelId = tg.channelId.trim();
|
|
if (!channelId) continue;
|
|
targets.push({ platform: "discord", channelId, threadId: tg.threadId.trim() || undefined });
|
|
}
|
|
}
|
|
|
|
const discordRoles = form.discordRolesText
|
|
.split(",")
|
|
.map((s) => s.trim())
|
|
.filter(Boolean);
|
|
|
|
return {
|
|
id: form.id.trim(),
|
|
name: form.name.trim(),
|
|
enabled: form.enabled,
|
|
fallback: form.fallback || undefined,
|
|
stop: form.stop || undefined,
|
|
discordRoleIds: discordRoles.length ? discordRoles : undefined,
|
|
filters,
|
|
...(ast ? { ast } : {}),
|
|
targets,
|
|
};
|
|
}
|
|
|
|
function validated(): Route | null {
|
|
const route = collect();
|
|
if (!route) return null;
|
|
if (!/^[a-z0-9][a-z0-9-]*$/.test(route.id)) {
|
|
formError.value = t("routeEditor.errIdFormat");
|
|
return null;
|
|
}
|
|
if (!route.name) {
|
|
formError.value = t("routeEditor.errName");
|
|
return null;
|
|
}
|
|
if (!route.targets.length) {
|
|
targetError.value = t("routeEditor.errTargets");
|
|
return null;
|
|
}
|
|
form.targets.forEach((tg, i) => {
|
|
if ((tg.platform === "telegram" || tg.platform === "feishu") && !tg.chatId.trim()) {
|
|
targetError.value = t("routeEditor.errChat", { n: i + 1 });
|
|
} else if (tg.platform === "discord" && !tg.channelId.trim()) {
|
|
targetError.value = t("routeEditor.errChannel", { n: i + 1 });
|
|
}
|
|
});
|
|
return targetError.value ? null : route;
|
|
}
|
|
|
|
function save(): void {
|
|
const route = validated();
|
|
if (route) {
|
|
emit("save", route);
|
|
return;
|
|
}
|
|
// The footer button may be far from the failing section: bring the error into view.
|
|
nextTick(() =>
|
|
bodyEl.value
|
|
?.querySelector("[data-save-error]")
|
|
?.scrollIntoView({ block: "center", behavior: "smooth" }),
|
|
);
|
|
}
|
|
|
|
function close(): void {
|
|
emit("close");
|
|
}
|
|
|
|
function onOpenChange(open: boolean): void {
|
|
if (!open) close();
|
|
}
|
|
|
|
async function runTest(): Promise<void> {
|
|
testError.value = "";
|
|
testResult.value = null;
|
|
let payload: unknown;
|
|
try {
|
|
payload = JSON.parse(testPayload.value);
|
|
} catch {
|
|
testError.value = t("routeEditor.testInvalidJson");
|
|
return;
|
|
}
|
|
const node = formToNode(root.value);
|
|
if (!node) {
|
|
testError.value = t("routeEditor.errAddFilter");
|
|
return;
|
|
}
|
|
testing.value = true;
|
|
try {
|
|
testResult.value = await apiFetch<{ matched: boolean; explanation: string }>(
|
|
"/admin/api/test-match",
|
|
{
|
|
method: "POST",
|
|
body: JSON.stringify({ node, event: testEvent.value.trim() || undefined, payload }),
|
|
},
|
|
);
|
|
} catch (err) {
|
|
testError.value = err instanceof Error ? err.message : String(err);
|
|
} finally {
|
|
testing.value = false;
|
|
}
|
|
}
|
|
|
|
function insertNode(node: FilterNode): void {
|
|
const child = nodeToForm(node);
|
|
if (root.value.kind === "all" || root.value.kind === "any") {
|
|
root.value.children.push(child);
|
|
} else {
|
|
root.value = {
|
|
kind: "all",
|
|
leaf: blankLeafForm(),
|
|
children: [root.value, child],
|
|
child: null,
|
|
};
|
|
}
|
|
}
|
|
|
|
function insertFragment(frag: NamedFragment): void {
|
|
insertNode(frag.node);
|
|
}
|
|
|
|
async function saveAsFragment(): Promise<void> {
|
|
fragmentError.value = "";
|
|
const name = fragmentName.value.trim();
|
|
if (!name) {
|
|
fragmentError.value = t("routeEditor.fragmentsNameRequired");
|
|
return;
|
|
}
|
|
if (!props.groupId) return;
|
|
const node = formToNode(root.value);
|
|
if (!node) {
|
|
fragmentError.value = t("routeEditor.errAddFilter");
|
|
return;
|
|
}
|
|
const id = `frag-${Math.random().toString(36).slice(2, 10)}`;
|
|
const next: NamedFragment[] = [
|
|
...fragments.value.filter((f) => f.id !== id),
|
|
{ id, groupId: props.groupId, name, node },
|
|
];
|
|
try {
|
|
await saveFragments(props.groupId, next);
|
|
fragmentName.value = "";
|
|
} catch (err) {
|
|
fragmentError.value = err instanceof Error ? err.message : String(err);
|
|
}
|
|
}
|
|
|
|
async function deleteFragment(frag: NamedFragment): Promise<void> {
|
|
const groupId = props.groupId;
|
|
if (!groupId) return;
|
|
if (!(await confirm({ title: t("confirm.deleteFragment", { name: frag.name }) }))) return;
|
|
fragmentError.value = "";
|
|
const next = fragments.value.filter((f) => f.id !== frag.id);
|
|
try {
|
|
await saveFragments(groupId, next);
|
|
} catch (err) {
|
|
fragmentError.value = err instanceof Error ? err.message : String(err);
|
|
}
|
|
}
|
|
|
|
watch(
|
|
() => props.open,
|
|
(open) => {
|
|
if (!open) return;
|
|
const r = props.route;
|
|
form.id = r?.id ?? "";
|
|
form.name = r?.name ?? "";
|
|
form.enabled = r?.enabled ?? true;
|
|
form.fallback = r?.fallback ?? false;
|
|
form.stop = r?.stop ?? false;
|
|
form.discordRolesText = r?.discordRoleIds?.length ? r.discordRoleIds.join(", ") : "";
|
|
form.targets =
|
|
r && r.targets.length
|
|
? r.targets.map((tg) => {
|
|
const merged = { ...blankTarget(), ...tg };
|
|
merged.platform =
|
|
merged.platform === "telegram" || merged.platform === "feishu"
|
|
? merged.platform
|
|
: "discord";
|
|
return merged;
|
|
})
|
|
: [blankTarget()];
|
|
if (r?.ast) {
|
|
root.value = nodeToForm(r.ast);
|
|
} else if (r && r.filters.length) {
|
|
root.value = nodeToForm({ all: r.filters });
|
|
} else {
|
|
root.value = blankNode("all");
|
|
}
|
|
filterError.value = "";
|
|
targetError.value = "";
|
|
formError.value = "";
|
|
testPayload.value = "";
|
|
testEvent.value = "";
|
|
testResult.value = null;
|
|
testError.value = "";
|
|
fragmentName.value = "";
|
|
fragmentError.value = "";
|
|
if (props.groupId) loadFragments(props.groupId);
|
|
},
|
|
);
|
|
</script>
|
|
|
|
<template>
|
|
<RcDialog
|
|
:open="open"
|
|
:title="isEdit ? t('routeEditor.editTitle') : t('routeEditor.newTitle')"
|
|
class="editor-dialog flex flex-col gap-0 max-h-[calc(100dvh-2rem)] overflow-hidden p-0 max-w-4xl"
|
|
@update:open="onOpenChange"
|
|
>
|
|
<template #header>
|
|
<div class="editor-head">
|
|
<div class="editor-heading">
|
|
<span class="editor-eyebrow">{{ t("routeEditor.eyebrow") }}</span>
|
|
<h2>{{ isEdit ? t("routeEditor.editTitle") : t("routeEditor.newTitle") }}</h2>
|
|
</div>
|
|
</div>
|
|
</template>
|
|
|
|
<form ref="bodyEl" class="editor-body" @submit.prevent="save">
|
|
<section class="editor-section">
|
|
<h3 class="editor-section-title">{{ t("routeEditor.sectionBasic") }}</h3>
|
|
<div v-if="!isEdit" class="templates">
|
|
<RcButton
|
|
v-for="tmpl in ROUTE_TEMPLATES"
|
|
:key="tmpl.id"
|
|
type="button"
|
|
variant="ghost"
|
|
size="sm"
|
|
:class="form.id === tmpl.id ? 'template-chip active' : 'template-chip'"
|
|
@click="applyTemplate(tmpl)"
|
|
>
|
|
{{ t(tmpl.nameKey) }}
|
|
</RcButton>
|
|
</div>
|
|
<div class="row2">
|
|
<div class="field">
|
|
<label>{{ t("routeEditor.name") }}</label>
|
|
<RcInput v-model="form.name" :placeholder="t('routeEditor.namePlaceholder')" required />
|
|
</div>
|
|
<div class="field">
|
|
<label>{{ t("routeEditor.id") }}</label>
|
|
<RcInput v-model="form.id" placeholder="my-route" required />
|
|
<div class="hint">{{ t("routeEditor.idHint") }}</div>
|
|
</div>
|
|
</div>
|
|
</section>
|
|
|
|
<section class="editor-section">
|
|
<h3 class="editor-section-title">{{ t("routeEditor.sectionOptions") }}</h3>
|
|
<div class="option-list">
|
|
<div class="option-row">
|
|
<RcSwitch v-model="form.enabled" :label="t('routeEditor.enabled')" />
|
|
</div>
|
|
<div class="option-row">
|
|
<RcCheckbox v-model="form.fallback" :label="t('routeEditor.fallback')" />
|
|
<p class="option-hint">{{ t("routeEditor.fallbackHint") }}</p>
|
|
</div>
|
|
<div class="option-row">
|
|
<RcCheckbox v-model="form.stop" :label="t('routeEditor.stop')" />
|
|
<p class="option-hint">{{ t("routeEditor.stopHint") }}</p>
|
|
</div>
|
|
</div>
|
|
<div class="field">
|
|
<label>{{ t("routeEditor.discordRoles") }}</label>
|
|
<RcTagInput
|
|
v-model="discordRoles"
|
|
separator=","
|
|
:placeholder="t('routeEditor.discordRolesPlaceholder')"
|
|
/>
|
|
<div class="hint">{{ t("routeEditor.discordRolesHint") }}</div>
|
|
</div>
|
|
</section>
|
|
|
|
<section class="editor-section">
|
|
<h3 class="editor-section-title">{{ t("routeEditor.sectionFilters") }}</h3>
|
|
<FilterNodeEditor :node="root" />
|
|
<div v-if="filterError" class="err" data-save-error>{{ filterError }}</div>
|
|
</section>
|
|
|
|
<section class="editor-section">
|
|
<h3 class="editor-section-title">{{ t("routeEditor.testMatch") }}</h3>
|
|
<div class="field">
|
|
<RcInput v-model="testEvent" :placeholder="t('routeEditor.testEvent')" />
|
|
</div>
|
|
<div class="field">
|
|
<RcTextarea
|
|
v-model="testPayload"
|
|
class="test-payload"
|
|
:rows="6"
|
|
:placeholder="t('routeEditor.testPayloadPlaceholder')"
|
|
/>
|
|
</div>
|
|
<div class="field">
|
|
<RcButton type="button" variant="ghost" :loading="testing" @click="runTest">
|
|
{{ testing ? "…" : t("routeEditor.testRun") }}
|
|
</RcButton>
|
|
</div>
|
|
<div v-if="testResult" class="test-result" :class="{ ok: testResult.matched }">
|
|
<span class="test-badge">
|
|
{{
|
|
testResult.matched ? t("routeEditor.testMatched") : t("routeEditor.testNotMatched")
|
|
}}
|
|
</span>
|
|
<span class="test-explanation">{{ testResult.explanation }}</span>
|
|
</div>
|
|
<div v-if="testError" class="err">{{ testError }}</div>
|
|
</section>
|
|
|
|
<section v-if="groupId" class="editor-section">
|
|
<h3 class="editor-section-title">{{ t("routeEditor.fragments") }}</h3>
|
|
<div class="fragments-presets">
|
|
<span class="hint">{{ t("routeEditor.fragmentsPresets") }}</span>
|
|
<div v-for="preset in FRAGMENT_PRESETS" :key="preset.id" class="fragment-row">
|
|
<span class="fragment-name">{{ t(preset.nameKey) }}</span>
|
|
<RcButton
|
|
type="button"
|
|
variant="ghost"
|
|
size="sm"
|
|
class="fragment-action"
|
|
@click="insertNode(preset.node)"
|
|
>
|
|
{{ t("routeEditor.fragmentsInsert") }}
|
|
</RcButton>
|
|
</div>
|
|
</div>
|
|
<div class="fragments-list">
|
|
<div v-if="!fragments.length" class="hint">{{ t("routeEditor.fragmentsEmpty") }}</div>
|
|
<div v-for="frag in fragments" :key="frag.id" class="fragment-row">
|
|
<span class="fragment-name">{{ frag.name }}</span>
|
|
<RcButton
|
|
type="button"
|
|
variant="ghost"
|
|
size="sm"
|
|
class="fragment-action"
|
|
@click="insertFragment(frag)"
|
|
>
|
|
{{ t("routeEditor.fragmentsInsert") }}
|
|
</RcButton>
|
|
<RcButton
|
|
type="button"
|
|
variant="ghost"
|
|
color="error"
|
|
size="icon"
|
|
class="h-8 w-8 text-muted hover:text-bad"
|
|
:title="t('routeEditor.fragmentsDelete')"
|
|
:aria-label="t('routeEditor.fragmentsDelete')"
|
|
@click="deleteFragment(frag)"
|
|
>
|
|
<Trash2 :size="15" />
|
|
</RcButton>
|
|
</div>
|
|
</div>
|
|
<div class="fragment-save">
|
|
<div class="fragment-save-input">
|
|
<RcInput
|
|
v-model="fragmentName"
|
|
:placeholder="t('routeEditor.fragmentsNamePlaceholder')"
|
|
/>
|
|
</div>
|
|
<RcButton
|
|
type="button"
|
|
variant="ghost"
|
|
class="shrink-0 whitespace-nowrap"
|
|
@click="saveAsFragment"
|
|
>
|
|
{{ t("routeEditor.fragmentsSave") }}
|
|
</RcButton>
|
|
</div>
|
|
<div v-if="fragmentError" class="err">{{ fragmentError }}</div>
|
|
</section>
|
|
|
|
<section class="editor-section">
|
|
<h3 class="editor-section-title">{{ t("routeEditor.sectionTargets") }}</h3>
|
|
<div v-for="(tg, i) in form.targets" :key="i" class="target-card">
|
|
<div class="target-card-head">
|
|
<div class="target-platform">
|
|
<RcSelect
|
|
v-model="tg.platform"
|
|
:options="[
|
|
{ label: 'Discord', value: 'discord' },
|
|
{ label: 'Telegram', value: 'telegram' },
|
|
{ label: t('routeEditor.platformFeishu'), value: 'feishu' },
|
|
]"
|
|
/>
|
|
</div>
|
|
<RcButton
|
|
type="button"
|
|
variant="ghost"
|
|
color="error"
|
|
size="icon"
|
|
class="h-8 w-8 text-muted hover:text-bad"
|
|
:title="t('routeEditor.removeTarget')"
|
|
:aria-label="t('routeEditor.removeTarget')"
|
|
@click="removeTarget(tg)"
|
|
>
|
|
<Trash2 :size="15" />
|
|
</RcButton>
|
|
</div>
|
|
<template v-if="tg.platform === 'discord'">
|
|
<div class="target-field">
|
|
<label :for="`target-${i}-channel`">{{ t("routeEditor.channel") }}</label>
|
|
<RcInput
|
|
:id="`target-${i}-channel`"
|
|
v-model="tg.channelId"
|
|
:placeholder="t('routeEditor.channelPlaceholder')"
|
|
/>
|
|
</div>
|
|
<div class="target-field">
|
|
<label :for="`target-${i}-thread`"
|
|
>{{ t("routeEditor.thread") }}
|
|
<span class="lbl-note">{{ t("routeEditor.threadNote") }}</span></label
|
|
>
|
|
<RcInput
|
|
:id="`target-${i}-thread`"
|
|
v-model="tg.threadId"
|
|
:placeholder="t('routeEditor.threadPlaceholder')"
|
|
/>
|
|
</div>
|
|
</template>
|
|
<template v-else>
|
|
<div class="target-field">
|
|
<label :for="`target-${i}-chat`">{{ t("routeEditor.chat") }}</label>
|
|
<RcInput
|
|
:id="`target-${i}-chat`"
|
|
v-model="tg.chatId"
|
|
:placeholder="
|
|
tg.platform === 'telegram'
|
|
? t('routeEditor.chatPlaceholder')
|
|
: t('routeEditor.feishuChatPlaceholder')
|
|
"
|
|
/>
|
|
</div>
|
|
<div v-if="tg.platform === 'telegram'" class="target-field">
|
|
<label :for="`target-${i}-topic`"
|
|
>{{ t("routeEditor.topic") }}
|
|
<span class="lbl-note">{{ t("routeEditor.topicNote") }}</span></label
|
|
>
|
|
<RcInput
|
|
:id="`target-${i}-topic`"
|
|
v-model="tg.topicId"
|
|
:placeholder="t('routeEditor.topicPlaceholder')"
|
|
/>
|
|
</div>
|
|
</template>
|
|
</div>
|
|
<RcButton type="button" variant="ghost" class="add-filter" @click="addTarget">
|
|
{{ t("routeEditor.addTarget") }}
|
|
</RcButton>
|
|
<div v-if="targetError" class="err" data-save-error>{{ targetError }}</div>
|
|
</section>
|
|
|
|
<div v-if="formError" class="err" data-save-error>{{ formError }}</div>
|
|
</form>
|
|
|
|
<template #footer>
|
|
<div class="editor-foot">
|
|
<RcButton variant="ghost" @click="close">{{ t("routeEditor.cancel") }}</RcButton>
|
|
<RcButton variant="primary" :loading="saving" @click="save">
|
|
{{ t("routeEditor.save") }}
|
|
</RcButton>
|
|
</div>
|
|
</template>
|
|
</RcDialog>
|
|
</template>
|
|
|
|
<style scoped>
|
|
:deep(.editor-foot) {
|
|
display: flex;
|
|
justify-content: flex-end;
|
|
gap: 0.5rem;
|
|
border-top: 1px solid rgb(var(--wh-border));
|
|
background: rgb(var(--wh-surface));
|
|
padding: 1rem 1.5rem;
|
|
box-shadow: 0 -8px 24px -16px rgba(15, 23, 42, 0.18);
|
|
}
|
|
</style>
|