@webx-ui/module-events 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 webx-ui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# @webx-ui/module-events
+
+The front end of the events section of the [WebX UI](https://github.com/webx-ui/webx-ui) admin
+panel: workshops, meetings and webinars — a date and a time, a place, a price and a link to book,
+a gallery and «What to expect» — and the categories they are filed under.
+
+The other half is the Composer package `webx-ui/module-events`, which owns the events, their pages
+and addresses, the `.ics` files, the `Event` markup, `events()` for templates and the API. A section
+appears in the panel when both halves are installed.
+
+## Install
+
+```bash
+npm install @webx-ui/module-events
+```
+
+```ts
+import { createAdmin } from '@webx-ui/module-admin'
+import { events } from '@webx-ui/module-events'
+import '@webx-ui/module-events/style.css'
+
+createAdmin({
+  basePath: '/cms',
+  modules: [...events()],
+}).mount()
+```
+
+`events()` answers with two sections — the events and their categories — because the panel draws
+one entry per module. The server puts both in the `events` group. `events({ path: '/calendar' })`
+puts them somewhere else inside the panel.
+
+## What is here
+
+- **The list** — a page at a time, with tabs for when: the events to come (the default), the past
+  ones, all — the past ones dimmed — and the bin. The date column is the line the site prints, with
+  the exact moments in the tip. «Duplicate» is in the row menu.
+- **The editor** — the described screen `events.form` with the tabs Event · Settings · SEO ·
+  History, autosaved into a draft and guarded by a revision. The dates travel with their offset,
+  so the same event reads the same hour in every browser; an event of days (All day) shows the
+  same calendar days everywhere. «Duplicate» in the bar saves, copies and opens the copy. The
+  categories and the services wait in the draft with the text and reach the site on «Publish». A
+  project adds its own fields with a patch into the `project-fields` card.
+- **Categories** — the panel's shared category screens (`categoryRoutes`), with
+  `eventCategoriesOptions()` exported for a panel that mounts them elsewhere.
+
+The words are English by default and come from the server in the panel's language
+(`webx-events::`).
+
+Documentation: https://webx-ui.github.io/webx-ui/guide/events.html
+
+## License
+
+MIT

package/dist/EventCreateDialog.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    field: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/EventEditorPage.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The editor of one event: a head that stays put, the described screen under it, and the bar
+ * along the bottom where it is saved, duplicated and published (§4.9).
+ *
+ * Everything between the head and the bar is `events.form` — the event, its settings, the SEO
+ * card `module-seo` patches on and the history — so a project adds its own field with a patch
+ * rather than a fork of this file. Saving is by autosave into the draft, and the draft carries
+ * the categories and the services too: the site changes, all of it at once, only on "Publish".
+ * Edits are guarded by a revision: a save over somebody else's is refused with a 409 and the
+ * question of which version the site gets.
+ *
+ * The dates are moments with their offset (`valueFormat` on the screen's pickers), so the same
+ * event reads the same hour in every browser and the server keeps it in its own zone (decision
+ * 15). What the head prints under the name is the server's line (`when`, §4.6), not ours: it is
+ * the line the site prints, `date_note` included, and a second formatter here would disagree
+ * with it sooner or later.
+ */
+type __VLS_Props = {
+    base?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    base: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/EventHistory.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/EventsPage.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The section: a page of events with the filters of §4.9 over it.
+ *
+ * A paginator and not a sortable list, which is the whole difference from recipes: events have
+ * no order of their own — the date is the order (decision 4) — and they pile up for years, so the
+ * screen is twenty rows, the filters and a page number.
+ *
+ * The tabs are *when*, not the state: the upcoming ones are what an editor comes here for and
+ * what the site's lists show, so they are the list with nothing chosen. The past ones are a tab
+ * away, and "all" draws the past ones muted, so the line between the two can be seen at a glance.
+ * The state, the category and the service live behind the funnel.
+ *
+ * Below {@link CARDS} the row becomes a card, the way the articles do it: the cover on the left,
+ * everything else beside it.
+ */
+type __VLS_Props = {
+    base?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    base: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    root: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/api.d.ts

@@ -0,0 +1,38 @@
+import { AdminContext } from '@webx-ui/module-admin';
+import { EventDetail, EventInput, EventQuery, EventRow, EventSave, EventsPage, EventVersion } from './types';
+export interface EventsApi {
+    /** A page of events, with what the list can be narrowed by. */
+    list(query?: EventQuery): Promise<EventsPage>;
+    /** One event as its editor opens it: the record, the screen's values and the revision. */
+    get(id: number): Promise<EventDetail>;
+    /** A new event, made in one transaction: a refused address leaves no bare row behind. */
+    create(input: EventInput): Promise<EventDetail>;
+    /**
+     * Save the draft. Refused with a 409 when the revision is stale — the body is an
+     * {@link EventConflict} with the event as it now is.
+     */
+    save(id: number, input: EventSave): Promise<EventDetail>;
+    /** Throw away what is waiting and keep what the site is showing. */
+    discard(id: number): Promise<EventDetail>;
+    /**
+     * A copy as a draft that was never published: every field, the categories and the services,
+     * the same title and an address with the next free suffix (decision 9). The answer is the
+     * copy's form, so the editor can open it straight away.
+     */
+    duplicate(id: number): Promise<EventDetail>;
+    publish(id: number): Promise<EventRow>;
+    unpublish(id: number): Promise<EventRow>;
+    remove(id: number): Promise<void>;
+    restore(id: number): Promise<EventRow>;
+    /** The publications, newest first. */
+    versions(id: number): Promise<EventVersion[]>;
+    /** An old publication becomes the draft; putting it on the site is a separate step. */
+    restoreVersion(id: number, number: number): Promise<EventDetail>;
+}
+/** The path of the list under the panel's API. */
+export declare const EVENTS_API = "events";
+/**
+ * Everything under `/events`, below the panel's API path (§4.10) — except the categories, which
+ * are the panel's shared category API under `events/categories`.
+ */
+export declare function createEventsApi(admin: AdminContext): EventsApi;

package/dist/days.d.ts

@@ -0,0 +1,19 @@
+import { ScreenModel } from '@webx-ui/schema';
+/**
+ * The same wall clock in the reader's own zone: `2026-10-12T00:00:00+08:00` read in New York
+ * becomes `2026-10-12T00:00:00-04:00`.
+ *
+ * For an event of days the server keeps whole days in its own zone (§4.10) — midnight of the
+ * first, `23:59:59` of the last — and the moment is not the point, the calendar date is. A date
+ * picker reads a moment, though, and midnight at +08:00 is still the day before in New York, while
+ * `23:59:59` in UTC is already the day after at +08:00: the same event would show a different
+ * first or last day in every browser that is not in the site's zone. Moved onto the reader's
+ * clock, the picker shows the day the server named, and a save sends it back with the reader's
+ * offset — which the server cuts to a day in that same offset (`Moment::day()`), so it stays
+ * the same day both ways.
+ *
+ * Anything that is not such a string comes back as it was.
+ */
+export declare function onReadersClock(value: unknown): unknown;
+/** The values of `events.form` with the days of an event of days put on the reader's clock. */
+export declare function withDaysAsWritten(values: ScreenModel): ScreenModel;

package/dist/editor.d.ts

@@ -0,0 +1,19 @@
+import { InjectionKey, Ref } from 'vue';
+import { EventRow } from './types';
+/**
+ * What the editor knows and the nodes of `events.form` do not: the event being edited, and a way
+ * to read it again. The history needs both — its list is keyed by the event, and a restored
+ * version has to reach the fields the form is bound to.
+ */
+export interface EventEditorContext {
+    /** The event as the server last answered it, or `null` while the first request is out. */
+    event: Ref<EventRow | null>;
+    /** Whether this administrator may write at all. */
+    canManage: boolean;
+    /** Ask the server for the event again — after a restore, a publication, a discard. */
+    reload(): Promise<void>;
+}
+export declare const eventEditorKey: InjectionKey<EventEditorContext>;
+export declare function provideEventEditor(editor: EventEditorContext): void;
+/** The editor above this node, or `null` outside one — a demo or a test draws nothing. */
+export declare function useEventEditor(): EventEditorContext | null;

package/dist/i18n.d.ts

@@ -0,0 +1,2 @@
+/** Puts this package's English under the panel's dictionary, once per panel. */
+export declare function useEventsMessages(): void;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { events, eventCategoriesOptions, type EventsOptions } from './module';
+export { createEventsApi, EVENTS_API, type EventsApi } from './api';
+export { eventsMessages } from './messages';
+export { provideEventEditor, eventEditorKey, useEventEditor, type EventEditorContext, } from './editor';
+export { default as WxEventsPage } from './EventsPage';
+export { default as WxEventCreateDialog } from './EventCreateDialog';
+export { default as WxEventEditorPage } from './EventEditorPage';
+export { default as WxEventHistory } from './EventHistory';
+export type { EventConflict, EventDetail, EventInput, EventQuery, EventRow, EventSave, EventsPage, EventStatus, EventTermRef, EventVersion, EventWhen, } from './types';