@wssto2/vue-core 0.11.0 → 0.12.1

package/bin/templates/feature-crud/form.ts.tpl

@@ -0,0 +1,6 @@
+import { Create__FEATURE_ENTITY__InputSchema, type Create__FEATURE_ENTITY__Input } from "@/generated/routes/__FEATURE_ROUTE_MODULE__/schemas";
+
+// The Go input's rules (required, max) come from the generated schema; extend it here for what only the form knows.
+export const __FEATURE_FORM_SCHEMA__ = Create__FEATURE_ENTITY__InputSchema;
+
+export type __FEATURE_FORM_TYPE__ = Create__FEATURE_ENTITY__Input;

package/bin/templates/feature-crud/index.ts.tpl

@@ -0,0 +1,7 @@
+import type { IconName } from "@wssto2/vue-core/icon";
+
+export { __FEATURE_API_CLIENT__, __FEATURE_LIST__ } from "./api";
+export { __FEATURE_FORM_SCHEMA__ } from "./form";
+export type { __FEATURE_FORM_TYPE__ } from "./form";
+export type { __FEATURE_ENTITY__ } from "./types";
+export const MODULE_ICON: IconName = "fileTextLine";

package/bin/templates/feature-crud/routes.ts.tpl

@@ -0,0 +1,13 @@
+const __FEATURE_API_CLIENT__Routes = [
+  {
+    name: "__FEATURE_ROUTE_NAME__",
+    path: "__FEATURE_ROUTE_PATH__",
+    component: () => import("./views/Index.vue"),
+    meta: {
+      titleKey: "__FEATURE_I18N_MODULE__.title",
+      messages: ["__FEATURE_I18N_MODULE__"],
+    },
+  },
+] as const;
+
+export default __FEATURE_API_CLIENT__Routes;

package/bin/templates/feature-crud/tests/scaffold.test.ts.tpl

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+import { __FEATURE_API_CLIENT__, __FEATURE_LIST__ } from "..";
+
+describe("__FEATURE_API_CLIENT__ scaffold", () => {
+  it("defines the list over the generated route table", () => {
+    const http = {} as Parameters<typeof __FEATURE_API_CLIENT__>[0];
+    expect(__FEATURE_LIST__(__FEATURE_API_CLIENT__(http)).id).toBe("__FEATURE_I18N_MODULE__");
+  });
+});

package/bin/templates/feature-crud/types.ts.tpl

@@ -0,0 +1,3 @@
+import type { __FEATURE_ENTITY__Response } from "@/generated/routes/__FEATURE_ROUTE_MODULE__/entities";
+
+export type __FEATURE_ENTITY__ = __FEATURE_ENTITY__Response;

package/bin/templates/feature-crud/views/Index.vue.tpl

@@ -0,0 +1,36 @@
+<script setup lang="ts">
+import { CollectionPage, useCollection, type CollectionColumns } from "@wssto2/vue-core/collection";
+import type { PageAction } from "@wssto2/vue-core/page";
+import { usePlatform } from "@wssto2/vue-core/platform";
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { MODULE_ICON } from "@/features/__FEATURE_PATH__";
+import { __FEATURE_API_CLIENT__, __FEATURE_LIST__, type __FEATURE_ENTITY__Sort } from "../api";
+import type { __FEATURE_ENTITY__ } from "../types";
+import __FEATURE_ENTITY__Modal from "../components/__FEATURE_ENTITY__Modal.vue";
+
+const { t } = useI18n();
+const { access, http } = usePlatform();
+
+const featureModal = ref<InstanceType<typeof __FEATURE_ENTITY__Modal> | null>(null);
+
+// One columns array drives the table and the phone row: `mobile` says what a column is on a phone.
+const columns = computed(() => [
+  { key: "name", label: t("__FEATURE_I18N_MODULE__.table_columns.name"), kind: "identity", sort: "name", mobile: "primary", subtitle: (item: __FEATURE_ENTITY__) => `ID: ${item.id}` },
+  { key: "created_at", label: t("general.table_columns.created_at"), kind: "timestamp", sort: "created_at", width: 150, align: "center", mobile: "hidden" },
+  { key: "updated_at", label: t("general.table_columns.updated_at"), kind: "timestamp", sort: "updated_at", width: 150, align: "center", mobile: "hidden" },
+] satisfies CollectionColumns<__FEATURE_ENTITY__, __FEATURE_ENTITY__Sort>);
+
+const collection = useCollection(__FEATURE_LIST__(__FEATURE_API_CLIENT__(http)), { columns, state: { kind: "memory" } });
+
+const actions = computed<PageAction[]>(() => (access.can("__FEATURE_I18N_MODULE__:manage") ? [{
+  id: "create", label: t("__FEATURE_I18N_MODULE__.actions.create"), icon: "addLine", placement: "primary", compact: "icon",
+  keyboardShortcut: { key: "N", ctrlKey: true }, onClick: () => featureModal.value?.show(),
+}] : []));
+</script>
+
+<template>
+  <CollectionPage :collection="collection" :title="t('__FEATURE_I18N_MODULE__.title')" :description="t('__FEATURE_I18N_MODULE__.description')" :icon="MODULE_ICON" :actions="actions">
+    <__FEATURE_ENTITY__Modal ref="featureModal" @changed="collection.refresh()" />
+  </CollectionPage>
+</template>

package/bin/vue-core.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from "./cli.mjs";
+
+process.exitCode = await main(process.argv.slice(2));

package/dist/config/index.d.ts

@@ -0,0 +1,97 @@
+/** A debt ESLint cannot count itself (an inline `eslint-disable` is invisible to the rule it silences), ratcheted like a rule. */
+export interface LintPatternCounter {
+    /** The key in the baseline file and the line in the report. */
+    name: string;
+    /** File extensions scanned, with the dot: `[".vue", ".ts"]`. */
+    extensions: string[];
+    /** Matched line by line; give it the `g` flag. */
+    pattern: RegExp;
+    /** Printed beside every match in `--report` and in a ratchet failure. */
+    hint: string;
+}
+export interface LintConfig {
+    /** The baseline file, relative to the config file's folder. Default `scripts/lint-baselines.json`. */
+    baselines?: string;
+    /** Folders (by name, anywhere in the tree) that are not scanned and whose files are never in the typed scope. Default `["generated"]`. */
+    generated?: string[];
+    /** Default none. */
+    patternCounters?: LintPatternCounter[];
+    /** What the messages tell the developer to run, for an application that wraps the command in npm scripts. Each defaults to the `vue-core lint` call. */
+    commands?: {
+        update?: string;
+        typedUpdate?: string;
+        typedReport?: string;
+        typedReportAll?: string;
+    };
+    /** Where raising a ceiling is decided, named in the ratchet failure ("… is a CODEOWNERS decision — see <policy>"). */
+    policy?: string;
+}
+/** What an application's own architecture rule is given for each source file (.ts / .vue under the config's folder). */
+export interface ArchitectureFile {
+    /** path from the config file's folder, with `/` */
+    file: string;
+    content: string;
+    /** the inside of the `<template>` of a .vue file, else "" */
+    template: string;
+    /** import / re-export specifiers, in the order they appear */
+    imports: string[];
+    isVue: boolean;
+    /** under a tests/ folder or named *.test.* / *.spec.* */
+    isTest: boolean;
+}
+/** An application's own rule: the messages for one file (each is prefixed with the file's path), or none. */
+export type ArchitectureRule = (file: ArchitectureFile) => string[] | undefined;
+export interface ArchitectureConfig {
+    /** The folder of the features, relative to the config file (default "features"). */
+    featuresDir?: string;
+    /** The import alias that points at the config file's folder (default `@/`). */
+    alias?: string;
+    /** Folders that import no feature (default components, composables). */
+    sharedLayers?: string[];
+    /** Folders (inside the config's folder) the walk skips, by name (default dist, generated, node_modules). */
+    skip?: string[];
+    /** Folders the "design-values" pack checks (default the features folder and "components"). */
+    uiDirs?: string[];
+    /**
+     * Generated code: its folder under the alias and the subpaths code may import ("entities/*" a folder, "permissions" one module;
+     * default entities, schemas, routes). `moved` maps an old import prefix to its new home (old prefix to new home, each with the alias).
+     */
+    generated?: {
+        dir?: string;
+        allowed?: string[];
+        moved?: Record<string, string>;
+    };
+    /**
+     * Known offenders that predate a rule, by rule: "deep-import" (`<file> -> <specifier>`), "raw-http", "feature-name" and
+     * "feature-shape" (paths), and a pack rule's id (files; a stale entry is a violation, so the list only shrinks).
+     */
+    allow?: Record<string, string[]>;
+    /** Opt-in rule packs: "design-values" (theme tokens) and "presentation" (use the library's components). */
+    packs?: ("design-values" | "presentation")[];
+    /** The application's own rules, run on every source file. */
+    rules?: ArchitectureRule[];
+    /** A document to name after a rule's message, by rule: "shared-layer", "api-error" or a pack rule's id. */
+    doc?: Record<string, string>;
+}
+export interface GeneratorConfig {
+    /** The template folder (`*.tpl` files, `__FEATURE_*__` placeholders), relative to the config's folder. Default: the one shipped with vue-core. */
+    template?: string;
+    /** Where feature folders are made, relative to the config's folder. Default: `"features"`. */
+    out?: string;
+}
+export interface E2eTimingsConfig {
+    /** The Playwright JSON report (`reporter: [["json", { outputFile }]]`), relative to the config's folder. Default: `"e2e-timings/results.json"`. */
+    report?: string;
+}
+export interface VueCoreConfig {
+    /** `vue-core lint` */
+    lint?: LintConfig;
+    /** `vue-core check-architecture` */
+    architecture?: ArchitectureConfig;
+    /** `vue-core feature` */
+    generator?: GeneratorConfig;
+    /** `vue-core e2e-timings` */
+    e2eTimings?: E2eTimingsConfig;
+}
+/** Types a `vue-core.config.mjs` (`export default defineConfig({ … })`); returns the config unchanged. */
+export declare function defineConfig(config: VueCoreConfig): VueCoreConfig;

package/dist/config/index.js

@@ -0,0 +1,6 @@
+function e(n) {
+  return n;
+}
+export {
+  e as defineConfig
+};

package/dist/eslint/index.d.ts

@@ -0,0 +1,28 @@
+import type { Linter } from "eslint";
+/**
+ * The rules that require type information. An explicit list rather than something derived at runtime: the driver once read
+ * it back out of the baseline file, which is empty on a first run, so every typed rule was filed under the syntactic section,
+ * where the fast path then compared it against a count it never measured.
+ */
+export declare const TYPED_RULES: readonly string[];
+export declare const TYPED_RULE_SET: ReadonlySet<string>;
+export interface VueCoreConfigOptions {
+    /**
+     * Turn on the type-aware rules (`TYPED_RULES`, at `warn`: the ratchet counts them). Type-aware linting is slow, so it is
+     * opt-in. The application decides how: `typed: process.env.LINT_TYPED === "1"`, the variable `vue-core lint` is run with. Default `false`.
+     */
+    typed?: boolean;
+    /** The folder of the tsconfig the project service reads. Required when `typed`; usually `import.meta.dirname`. */
+    tsconfigRootDir?: string;
+    /** Ignored in addition to `dist`, `node_modules`, `coverage` and `**\/*.d.ts` (for example the generated code). */
+    ignores?: string[];
+    /** Your own rule choices; they win over the defaults here, the typed rules included (`{ "…/no-floating-promises": "error" }`). */
+    rules?: Linter.RulesRecord;
+}
+/**
+ * The flat config: ESLint, typescript-eslint and Vue recommended sets, browser and Node globals, the Vue template parser on
+ * TypeScript, the template-formatting rules off (not enforced without a Prettier pass over templates), and the typed block.
+ * Spread it and add your own objects after it:
+ * `export default [...vueCoreConfig({ typed, tsconfigRootDir: import.meta.dirname, rules: { … } }), { files: […], rules: … }]`.
+ */
+export declare function vueCoreConfig({ typed, tsconfigRootDir, ignores, rules }?: VueCoreConfigOptions): Linter.Config[];

package/dist/eslint/index.js

@@ -0,0 +1,87 @@
+import l from "@eslint/js";
+import u from "eslint-plugin-vue";
+import r from "globals";
+import t from "typescript-eslint";
+import a from "vue-eslint-parser";
+const o = [
+  "@typescript-eslint/await-thenable",
+  "@typescript-eslint/no-base-to-string",
+  "@typescript-eslint/no-floating-promises",
+  "@typescript-eslint/no-misused-promises",
+  "@typescript-eslint/no-redundant-type-constituents",
+  "@typescript-eslint/no-unnecessary-type-assertion",
+  "@typescript-eslint/no-unsafe-argument",
+  "@typescript-eslint/no-unsafe-assignment",
+  "@typescript-eslint/no-unsafe-call",
+  "@typescript-eslint/no-unsafe-enum-comparison",
+  "@typescript-eslint/no-unsafe-member-access",
+  "@typescript-eslint/no-unsafe-return",
+  "@typescript-eslint/prefer-promise-reject-errors",
+  "@typescript-eslint/require-await",
+  "@typescript-eslint/restrict-plus-operands",
+  "@typescript-eslint/restrict-template-expressions",
+  "@typescript-eslint/unbound-method"
+], y = new Set(o);
+function b({ typed: e = !1, tsconfigRootDir: n, ignores: i = [], rules: p = {} } = {}) {
+  if (e && !n) throw new Error("vueCoreConfig: typed linting needs tsconfigRootDir (usually import.meta.dirname)");
+  return [
+    { ignores: ["dist/**", "node_modules/**", "coverage/**", "**/*.d.ts", ...i] },
+    l.configs.recommended,
+    ...t.configs.recommended,
+    ...u.configs["flat/recommended"],
+    { files: ["**/*.{js,mjs,ts,vue}"], languageOptions: { globals: { ...r.browser, ...r.node } } },
+    // `recommended` alone cannot see types, so it misses no-floating-promises (an unawaited call swallows its rejection),
+    // no-misused-promises, await-thenable and require-await.
+    ...e ? t.configs.recommendedTypeChecked.map((s) => ({ ...s, files: ["**/*.{ts,vue}"] })) : [],
+    {
+      files: ["**/*.vue"],
+      languageOptions: {
+        parser: a,
+        parserOptions: { parser: t.parser, sourceType: "module", extraFileExtensions: [".vue"] }
+      }
+    },
+    ...e ? [{ files: ["**/*.{ts,vue}"], languageOptions: { parserOptions: { projectService: !0, tsconfigRootDir: n } } }] : [],
+    // Config and tooling files are usually outside tsconfig's `include`: no type information, and without this they fail to parse.
+    { files: ["**/*.{js,mjs,cjs}"], ...t.configs.disableTypeChecked },
+    {
+      files: ["**/*.{ts,vue}"],
+      rules: {
+        // TypeScript reports undefined references itself, and no-undef cannot see ambient global types.
+        "no-undef": "off",
+        ...e ? Object.fromEntries(o.map((s) => [s, "warn"])) : {},
+        // Superseded by @typescript-eslint/no-unused-vars below; the core rule mis-fires on type-only constructs.
+        "no-unused-vars": "off",
+        "no-useless-assignment": "error",
+        "@typescript-eslint/no-empty-object-type": "error",
+        "vue/no-ref-as-operand": "error",
+        "vue/no-unused-vars": "error",
+        "vue/multi-word-component-names": "off",
+        // flat/recommended pulls in the template *formatting* rules; the correctness rules of the set stay on.
+        "vue/max-attributes-per-line": "off",
+        "vue/html-indent": "off",
+        "vue/html-closing-bracket-newline": "off",
+        "vue/first-attribute-linebreak": "off",
+        "vue/singleline-html-element-content-newline": "off",
+        "vue/multiline-html-element-content-newline": "off",
+        "vue/html-self-closing": "off",
+        "vue/attributes-order": "off",
+        "vue/no-v-html": "error",
+        // `v-model="props.x"` stays an error; shallowOnly lets a controller passed down as a prop expose writable refs.
+        "vue/no-mutating-props": ["error", { shallowOnly: !0 }],
+        // `_`-prefixed identifiers are a deliberately unused binding.
+        "@typescript-eslint/no-unused-vars": [
+          "error",
+          { argsIgnorePattern: "^_", varsIgnorePattern: "^_", caughtErrorsIgnorePattern: "^_", destructuredArrayIgnorePattern: "^_" }
+        ],
+        ...p
+      }
+    },
+    // Test doubles define stub components inline, several per file, with untyped prop lists on purpose.
+    { files: ["**/*.test.ts"], languageOptions: { globals: r.vitest }, rules: { "vue/require-prop-types": "off", "vue/one-component-per-file": "off" } }
+  ];
+}
+export {
+  o as TYPED_RULES,
+  y as TYPED_RULE_SET,
+  b as vueCoreConfig
+};

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 /** The version of @wssto2/vue-core (kept equal to package.json by index.test.ts). */
-export declare const version = "0.11.0";
+export declare const version = "0.12.1";

package/dist/index.js

@@ -1,4 +1,4 @@
-const o = "0.11.0";
+const o = "0.12.1";
 export {
   o as version
 };

package/dist/modules/identity/entities.d.ts

@@ -22,7 +22,7 @@ export type ChangeRow = {
 export type ChangeView = "all" | "access" | "details";
 export type ClauseInfo = {
     scope: Scope;
-    qualifier: number;
+    qualifier: Qualifier;
     attrs?: Record<string, string[]>;
     role?: string;
     binding_id?: number;
@@ -56,7 +56,7 @@ export type PendingEmail = {
 };
 export type PermissionAccess = {
     scope: Scope;
-    qualifier: number;
+    qualifier: Qualifier;
     clauses: ClauseInfo[];
 };
 export type PersonRef = {
@@ -73,6 +73,7 @@ export type ProfileResponse = {
     created_at: string;
     pending_email: PendingEmail | null;
 };
+export type Qualifier = "own" | "own_location" | "all";
 export type Scope = {
     level: string;
     id?: number;

package/dist/playwright/access.d.ts

@@ -0,0 +1,61 @@
+import type { Page, Route } from "@playwright/test";
+import type { Binding, Constraint, Grant, PersonRef, Role, RoleHolder, RoleSummary, Scope, ScopeOptions } from "../modules/access/entities";
+import { type Call } from "./request";
+/**
+ * go-core's access wire as it serves it under `/api/v1/iam` (the access module): the roles with their holders, compare and replace, the
+ * roles bindable at a place, and a person's (or a service account's) access, scopes and bindings. A fake with a little state, so a
+ * spec reads what it did through `calls` and the next read shows the change. It knows no role of yours: pass the roles, the places
+ * and the bindings your application has.
+ */
+export type { Binding, Constraint, Grant, Role, RoleSummary, Scope };
+export type { Call } from "./request";
+export declare const ORGANIZATION: Scope;
+/** A place below the organization (`scopeOf("dealer", 1, "Auto Zagreb")`). */
+export declare const scopeOf: (level: string, id: number, name: string) => Scope;
+/** A role as go-core sends it: a predefined one by its key, a custom one by its id as the ref. */
+export declare const role: (ref: string, over?: Partial<Role>) => Role;
+export declare const summary: ({ grants: _grants, ...rest }: Role) => RoleSummary;
+export declare const bindingOf: (id: number, of: Role, scope: Scope, createdBy?: PersonRef | null) => Binding;
+export type Hook = (route: Route, url: URL, method: string, body: unknown) => Promise<boolean | void> | boolean | void;
+export type AccessOptions = {
+    roles?: Role[];
+    holders?: Record<string, RoleHolder[]>;
+    /** The roles the actor may give at a place (default: every predefined role). */
+    bindable?: Role[];
+    /** The bindings of each subject, by `user:3` / `service:21`. */
+    bindings?: Record<string, Binding[]>;
+    /** The places a role can be given at (default only the organization). */
+    places?: ScopeOptions;
+    canManage?: boolean;
+    /** The id of the next role and binding the page creates (default one past the highest there is). */
+    next?: {
+        role?: number;
+        binding?: number;
+    };
+    /** Answers first; true means it answered. */
+    hook?: Hook;
+};
+export type AccessWire = {
+    calls: Call[];
+    roles: Role[];
+    bindings: Record<string, Binding[]>;
+    reads: string[];
+};
+/** A role the server refuses as invalid: `authz.invalid` with its problems as objects. */
+export declare const invalid: (problems: {
+    code: string;
+    permission?: string;
+    detail?: string;
+}[]) => {
+    body?: string | Buffer;
+    contentType?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    json?: any;
+    path?: string;
+    response?: import("playwright-core").APIResponse;
+    status?: number;
+};
+/** Answers go-core's access routes under `/api/v1/iam`. The page needs `mockAuth` too; register this after it. */
+export declare function serveAccess(page: Page, options?: AccessOptions): Promise<AccessWire>;

package/dist/playwright/envelope.d.ts

@@ -0,0 +1,37 @@
+import type { Route } from "@playwright/test";
+import type { ListResult } from "../client";
+import type { ViewCount } from "../modules/identity/entities";
+/** What `route.fulfill` takes: the status, content type and body of one answer. */
+export type Answer = NonNullable<Parameters<Route["fulfill"]>[0]>;
+/**
+ * go-core's success envelope. The library's HTTP client unwraps `data` only from a body that has `success` (the server always
+ * sends it), so a fixture for a record the library reads says it too.
+ */
+export declare const ok: <T>(data: T, meta?: unknown) => {
+    meta?: {} | null | undefined;
+    success: true;
+    data: T;
+};
+/** go-core's paged list: the rows as `data`, the numbers (and any views) in `meta`, as `web.Paginated` writes it. */
+export declare const pageOk: (rows: unknown[], meta?: Record<string, unknown>) => {
+    meta?: {} | null | undefined;
+    success: true;
+    data: unknown[];
+};
+/** go-core's datatable answer (a `ListResult`): the rows, the paging and `meta.views`, inside the envelope's `data`. */
+export declare const datatable: <Row>(rows: Row[], views?: ViewCount[], paging?: Partial<Omit<ListResult<Row>, "data" | "meta">>) => {
+    meta?: {} | null | undefined;
+    success: true;
+    data: ListResult<Row>;
+};
+/** A JSON answer for `route.fulfill`. */
+export declare const json: (body: unknown, status?: number) => Answer;
+/** An empty answer (`204`, a delete or a password change). */
+export declare const noContent: () => Answer;
+/** A server-sent-events answer: each event as one `data:` frame. */
+export declare const sse: (events: unknown[]) => Answer;
+/** A refusal as go-core sends it: the reason as `code`, its params, and the field it belongs to. */
+export declare const refusal: (status: number, code: string, extra?: {
+    params?: unknown;
+    field?: string;
+}) => Answer;

package/dist/playwright/index.d.ts

@@ -0,0 +1,13 @@
+export { datatable, json, noContent, ok, pageOk, refusal, sse } from "./envelope";
+export type { Answer } from "./envelope";
+export { accessOf, authBody, authResponse, defaultUser, mockAuth } from "./session";
+export type { HeldAt, MockAuthOptions, SessionExtra } from "./session";
+export { ORGANIZATION, bindingOf, invalid, role, scopeOf, serveAccess, summary } from "./access";
+export type { AccessOptions, AccessWire, Binding, Constraint, Grant, Hook, Role, RoleSummary, Scope } from "./access";
+export { device, notification, serveNotifications, setting } from "./notifications";
+export type { CategorySettings, Device, Item, QuietHours, Setting, Wire, WireOptions } from "./notifications";
+export { NEW_EMAIL, ownSession, ownSignin, pendingChange, profile, serveProfile } from "./profile";
+export type { ProfileAnswers, ProfileCall, ProfileOptions } from "./profile";
+export { activity, ago, change, freshState, person, serveUsers, serviceAccount, session, signin } from "./users";
+export type { UsersOptions, UsersRequest, UsersState, Write } from "./users";
+export type { Call } from "./request";