@svadmin/surface 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,143 @@
+import type { DataProvider } from '@svadmin/core';
+import type { ZodType } from 'zod';
+export declare const SURFACE_SCHEMA_VERSION: "surface/v1";
+export declare const SURFACE_LIMITS: {
+    readonly maxDataSources: 8;
+    readonly maxWidgets: 24;
+    readonly maxPageSize: 100;
+    readonly maxFilters: 8;
+    readonly maxSorters: 3;
+    readonly maxIdLength: 64;
+    readonly maxTitleLength: 120;
+    readonly maxJsonDepth: 64;
+    readonly maxJsonNodes: 10000;
+};
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
+export interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+export type SurfaceGridSpan = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+export interface SurfaceGridLayout {
+    readonly type: 'grid';
+    readonly columns: 12;
+    readonly gap?: 'sm' | 'md' | 'lg';
+}
+export interface SurfaceSort {
+    readonly field: string;
+    readonly order: 'asc' | 'desc';
+}
+export type SurfaceFilter = {
+    readonly field: string;
+    readonly operator: 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'startswith' | 'endswith';
+    readonly value: JsonPrimitive;
+} | {
+    readonly field: string;
+    readonly operator: 'in' | 'nin';
+    readonly value: readonly JsonPrimitive[];
+} | {
+    readonly field: string;
+    readonly operator: 'null' | 'nnull';
+};
+export interface ResourceListSource {
+    readonly id: string;
+    readonly type: 'resource-list';
+    readonly resource: string;
+    readonly pageSize?: number;
+    readonly sorters?: readonly SurfaceSort[];
+    readonly filters?: readonly SurfaceFilter[];
+}
+export interface ResourceOneSource {
+    readonly id: string;
+    readonly type: 'resource-one';
+    readonly resource: string;
+    readonly recordId: string | number;
+}
+export type ResourceListDataSource = ResourceListSource;
+export type ResourceOneDataSource = ResourceOneSource;
+export type SurfaceDataSource = ResourceListSource | ResourceOneSource;
+export interface SurfaceBinding {
+    readonly sourceId: string;
+    readonly pointer?: string;
+}
+export interface SurfaceWidget {
+    readonly id: string;
+    readonly type: string;
+    readonly props: JsonObject;
+    readonly binding?: SurfaceBinding;
+    readonly placement?: {
+        readonly columnSpan?: SurfaceGridSpan;
+    };
+}
+export interface SurfaceSpec {
+    readonly schemaVersion: typeof SURFACE_SCHEMA_VERSION;
+    readonly catalogVersion: string;
+    readonly surfaceId: string;
+    readonly title: string;
+    readonly layout: SurfaceGridLayout;
+    readonly dataSources: readonly SurfaceDataSource[];
+    readonly widgets: readonly SurfaceWidget[];
+}
+export interface SurfaceResourcePolicy {
+    readonly readFields: readonly string[];
+    readonly filterFields?: readonly string[];
+    readonly sortFields?: readonly string[];
+    readonly allowGetOne?: boolean;
+    readonly maxPageSize?: number;
+}
+export interface SurfacePolicy {
+    readonly resources: Readonly<Record<string, SurfaceResourcePolicy>>;
+}
+export type SurfaceCatalogDataKind = 'none' | 'scalar' | 'items';
+export interface SurfaceWidgetDefinition {
+    readonly type: string;
+    readonly dataKind: SurfaceCatalogDataKind;
+    readonly propsSchema: ZodType<unknown>;
+    /** 组件从绑定记录中读取的字段，由可信 Catalog 提供。 */
+    readonly getReferencedFields?: (props: JsonObject) => readonly string[];
+}
+export interface SurfaceCatalog {
+    readonly version: string;
+    readonly widgets: readonly SurfaceWidgetDefinition[];
+}
+export type SurfaceValidationCode = 'invalid_json' | 'unsupported_schema_version' | 'catalog_version_mismatch' | 'duplicate_id' | 'unknown_widget_type' | 'unknown_data_source' | 'invalid_binding_pointer' | 'invalid_widget_props' | 'resource_denied' | 'field_denied' | 'limit_exceeded';
+export interface SurfaceValidationIssue {
+    readonly code: SurfaceValidationCode;
+    readonly path: string;
+    readonly message: string;
+    readonly widgetId?: string;
+    readonly sourceId?: string;
+}
+export type SurfaceValidationResult = {
+    readonly ok: true;
+    readonly value: SurfaceSpec;
+} | {
+    readonly ok: false;
+    readonly issues: readonly SurfaceValidationIssue[];
+};
+export type SurfaceDataProvider = Pick<DataProvider, 'getList' | 'getOne'>;
+export interface SurfaceDataError {
+    readonly code: 'access_denied' | 'access_check_failed' | 'provider_failed' | 'provider_result_not_json' | 'binding_pointer_not_found';
+    readonly sourceId: string;
+    readonly message: string;
+}
+export type SurfaceWidgetDataState = {
+    readonly status: 'unbound';
+} | {
+    readonly status: 'loading';
+    readonly sourceId: string;
+} | {
+    readonly status: 'empty';
+    readonly sourceId: string;
+} | {
+    readonly status: 'ready';
+    readonly sourceId: string;
+    readonly value: JsonValue;
+} | {
+    readonly status: 'error';
+    readonly sourceId: string;
+    readonly error: SurfaceDataError;
+};
+export type SurfaceSourceDataState = Extract<SurfaceWidgetDataState, {
+    status: 'loading' | 'ready' | 'error';
+}>;

package/dist/types.js

@@ -0,0 +1,12 @@
+export const SURFACE_SCHEMA_VERSION = 'surface/v1';
+export const SURFACE_LIMITS = {
+    maxDataSources: 8,
+    maxWidgets: 24,
+    maxPageSize: 100,
+    maxFilters: 8,
+    maxSorters: 3,
+    maxIdLength: 64,
+    maxTitleLength: 120,
+    maxJsonDepth: 64,
+    maxJsonNodes: 10_000,
+};

package/dist/validation.d.ts

@@ -0,0 +1,2 @@
+import { type SurfaceCatalog, type SurfacePolicy, type SurfaceValidationResult } from './types.js';
+export declare function validateSurfaceSpec(input: unknown, catalog: SurfaceCatalog, policy: SurfacePolicy): SurfaceValidationResult;

package/dist/validation.js

@@ -0,0 +1,307 @@
+import { z } from 'zod';
+import { decodedJsonPointerToken, jsonPointer, jsonValueIssue } from './json.js';
+import { SURFACE_LIMITS, SURFACE_SCHEMA_VERSION, } from './types.js';
+const idSchema = z.string().min(1).max(SURFACE_LIMITS.maxIdLength).regex(/^[A-Za-z][A-Za-z0-9_-]*$/u);
+const fieldSchema = z.string().min(1).max(SURFACE_LIMITS.maxIdLength);
+const jsonPrimitiveSchema = z.union([z.string(), z.number().finite(), z.boolean(), z.null()]);
+const surfaceFilterSchema = z.discriminatedUnion('operator', [
+    z.object({
+        field: fieldSchema,
+        operator: z.enum(['eq', 'ne', 'lt', 'lte', 'gt', 'gte', 'contains', 'startswith', 'endswith']),
+        value: jsonPrimitiveSchema,
+    }).strict(),
+    z.object({
+        field: fieldSchema,
+        operator: z.enum(['in', 'nin']),
+        value: z.array(jsonPrimitiveSchema),
+    }).strict(),
+    z.object({
+        field: fieldSchema,
+        operator: z.enum(['null', 'nnull']),
+    }).strict(),
+]);
+const resourceListSchema = z.object({
+    id: idSchema,
+    type: z.literal('resource-list'),
+    resource: idSchema,
+    pageSize: z.number().int().positive().optional(),
+    sorters: z.array(z.object({ field: fieldSchema, order: z.enum(['asc', 'desc']) }).strict()).optional(),
+    filters: z.array(surfaceFilterSchema).optional(),
+}).strict();
+const resourceOneSchema = z.object({
+    id: idSchema,
+    type: z.literal('resource-one'),
+    resource: idSchema,
+    recordId: z.union([z.string(), z.number().finite()]),
+}).strict();
+const surfaceSpecSchema = z.object({
+    schemaVersion: z.string(),
+    catalogVersion: z.string().min(1),
+    surfaceId: idSchema,
+    title: z.string().min(1).max(SURFACE_LIMITS.maxTitleLength),
+    layout: z.object({
+        type: z.literal('grid'),
+        columns: z.literal(12),
+        gap: z.enum(['sm', 'md', 'lg']).optional(),
+    }).strict(),
+    dataSources: z.array(z.discriminatedUnion('type', [resourceListSchema, resourceOneSchema])),
+    widgets: z.array(z.object({
+        id: idSchema,
+        type: idSchema,
+        props: z.record(z.string(), z.unknown()),
+        binding: z.object({ sourceId: idSchema, pointer: z.string().optional() }).strict().optional(),
+        placement: z.object({ columnSpan: z.number().int().min(1).max(12).optional() }).strict().optional(),
+    }).strict()),
+}).strict();
+const forbiddenPropertyNames = new Set([
+    'class',
+    'className',
+    'color',
+    'href',
+    'html',
+    'innerHTML',
+    'src',
+    'style',
+    'url',
+]);
+const strictSchemaProbeKey = '__surface_unknown_property_probe__';
+function invalidJsonIssue(pathSegments, message) {
+    return { code: 'invalid_json', path: jsonPointer(pathSegments), message };
+}
+function schemaIssues(error) {
+    return error.issues.map((issue) => invalidJsonIssue(issue.path.map((segment) => typeof segment === 'symbol' ? String(segment) : segment), issue.message));
+}
+function catalogDefinitions(catalog) {
+    return new Map(catalog.widgets.map((widgetDefinition) => [widgetDefinition.type, widgetDefinition]));
+}
+function resourcePolicyFor(policy, resource) {
+    return Object.hasOwn(policy.resources, resource) ? policy.resources[resource] : undefined;
+}
+function sourcePolicyIssue(source, policy, index) {
+    const resourcePolicy = resourcePolicyFor(policy, source.resource);
+    if (!resourcePolicy) {
+        return {
+            code: 'resource_denied',
+            path: `/dataSources/${index}/resource`,
+            message: `Resource "${source.resource}" is not allowed`,
+            sourceId: source.id,
+        };
+    }
+    if (source.type === 'resource-one' && resourcePolicy.allowGetOne !== true) {
+        return {
+            code: 'resource_denied',
+            path: `/dataSources/${index}`,
+            message: `Resource "${source.resource}" does not allow getOne`,
+            sourceId: source.id,
+        };
+    }
+    if (source.type === 'resource-list') {
+        const pageSizeLimit = Math.min(resourcePolicy.maxPageSize ?? SURFACE_LIMITS.maxPageSize, SURFACE_LIMITS.maxPageSize);
+        if ((source.pageSize ?? 10) > pageSizeLimit) {
+            return {
+                code: 'limit_exceeded',
+                path: `/dataSources/${index}/pageSize`,
+                message: `Page size exceeds ${pageSizeLimit}`,
+                sourceId: source.id,
+            };
+        }
+        const disallowedSorter = source.sorters?.find((sorter) => !resourcePolicy.sortFields?.includes(sorter.field));
+        if (disallowedSorter) {
+            return {
+                code: 'field_denied',
+                path: `/dataSources/${index}/sorters`,
+                message: `Sorting by "${disallowedSorter.field}" is not allowed`,
+                sourceId: source.id,
+            };
+        }
+        const disallowedFilter = source.filters?.find((filter) => !resourcePolicy.filterFields?.includes(filter.field));
+        if (disallowedFilter) {
+            return {
+                code: 'field_denied',
+                path: `/dataSources/${index}/filters`,
+                message: `Filtering by "${disallowedFilter.field}" is not allowed`,
+                sourceId: source.id,
+            };
+        }
+    }
+    return null;
+}
+function propsContainForbiddenKey(props) {
+    const pending = [props];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined || current === null || typeof current !== 'object')
+            continue;
+        if (Array.isArray(current)) {
+            pending.push(...current);
+            continue;
+        }
+        for (const [key, entry] of Object.entries(current)) {
+            if (forbiddenPropertyNames.has(key) || key.startsWith('on'))
+                return key;
+            pending.push(entry);
+        }
+    }
+    return null;
+}
+function referencedFieldIssue(widget, widgetIndex, definition, source, policy) {
+    if (!definition.getReferencedFields)
+        return null;
+    let referencedFields;
+    try {
+        referencedFields = definition.getReferencedFields(widget.props);
+    }
+    catch {
+        return {
+            code: 'invalid_widget_props',
+            path: `/widgets/${widgetIndex}/props`,
+            message: 'Widget field references could not be resolved',
+            widgetId: widget.id,
+        };
+    }
+    const readableFields = resourcePolicyFor(policy, source.resource)?.readFields ?? [];
+    const deniedField = referencedFields.find((field) => (typeof field !== 'string' || !readableFields.includes(field)));
+    return deniedField === undefined
+        ? null
+        : {
+            code: 'field_denied',
+            path: `/widgets/${widgetIndex}/props`,
+            message: `Field "${String(deniedField)}" is not readable`,
+            widgetId: widget.id,
+            sourceId: source.id,
+        };
+}
+function resourceOnePointerField(pointer) {
+    if (!pointer.startsWith('/') || pointer.slice(1).includes('/'))
+        return null;
+    const field = decodedJsonPointerToken(pointer.slice(1));
+    return field && field.length <= SURFACE_LIMITS.maxIdLength ? field : null;
+}
+function widgetIssue(widget, widgetIndex, definition, sources, policy) {
+    if (!definition) {
+        return {
+            code: 'unknown_widget_type',
+            path: `/widgets/${widgetIndex}/type`,
+            message: `Widget type "${widget.type}" is not registered`,
+            widgetId: widget.id,
+        };
+    }
+    const forbiddenKey = propsContainForbiddenKey(widget.props);
+    const propsValidation = definition.propsSchema.safeParse(widget.props);
+    const strictSchemaProbe = definition.propsSchema.safeParse({
+        ...widget.props,
+        [strictSchemaProbeKey]: null,
+    });
+    if (forbiddenKey || !propsValidation.success || strictSchemaProbe.success) {
+        return {
+            code: 'invalid_widget_props',
+            path: `/widgets/${widgetIndex}/props`,
+            message: forbiddenKey
+                ? `Property "${forbiddenKey}" is not allowed`
+                : strictSchemaProbe.success
+                    ? 'Catalog props schema must reject unknown properties'
+                    : 'Widget props do not match the catalog schema',
+            widgetId: widget.id,
+        };
+    }
+    if (definition.dataKind === 'none') {
+        return widget.binding
+            ? {
+                code: 'invalid_binding_pointer',
+                path: `/widgets/${widgetIndex}/binding`,
+                message: 'This widget does not accept a data binding',
+                widgetId: widget.id,
+            }
+            : null;
+    }
+    const source = widget.binding ? sources.get(widget.binding.sourceId) : undefined;
+    if (!source) {
+        return {
+            code: 'unknown_data_source',
+            path: `/widgets/${widgetIndex}/binding/sourceId`,
+            message: 'Widget binding must reference an existing data source',
+            widgetId: widget.id,
+        };
+    }
+    const pointer = widget.binding?.pointer ?? '';
+    const resourceOneField = source.type === 'resource-one' ? resourceOnePointerField(pointer) : null;
+    const pointerIsValid = definition.dataKind === 'items'
+        ? source.type === 'resource-list' && pointer === '/items'
+        : (source.type === 'resource-list' && pointer === '/total')
+            || resourceOneField !== null;
+    if (!pointerIsValid) {
+        return {
+            code: 'invalid_binding_pointer',
+            path: `/widgets/${widgetIndex}/binding/pointer`,
+            message: 'Binding pointer is not valid for this widget and data source',
+            widgetId: widget.id,
+            sourceId: source.id,
+        };
+    }
+    const deniedReferencedField = referencedFieldIssue(widget, widgetIndex, definition, source, policy);
+    if (deniedReferencedField)
+        return deniedReferencedField;
+    if (source.type === 'resource-one' && resourceOneField !== null) {
+        if (!resourcePolicyFor(policy, source.resource)?.readFields.includes(resourceOneField)) {
+            return {
+                code: 'field_denied',
+                path: `/widgets/${widgetIndex}/binding/pointer`,
+                message: `Field "${resourceOneField}" is not readable`,
+                widgetId: widget.id,
+                sourceId: source.id,
+            };
+        }
+    }
+    return null;
+}
+function duplicateIdIssue(spec) {
+    const ids = new Set();
+    const entries = [
+        ...spec.dataSources.map((source, index) => ({ id: source.id, path: `/dataSources/${index}/id` })),
+        ...spec.widgets.map((widget, index) => ({ id: widget.id, path: `/widgets/${index}/id` })),
+    ];
+    for (const entry of entries) {
+        if (ids.has(entry.id))
+            return { code: 'duplicate_id', path: entry.path, message: `Duplicate id "${entry.id}"` };
+        ids.add(entry.id);
+    }
+    return null;
+}
+export function validateSurfaceSpec(input, catalog, policy) {
+    const unsafeJson = jsonValueIssue(input);
+    if (unsafeJson)
+        return { ok: false, issues: [invalidJsonIssue(unsafeJson.path, unsafeJson.message)] };
+    const parsedSpec = surfaceSpecSchema.safeParse(input);
+    if (!parsedSpec.success)
+        return { ok: false, issues: schemaIssues(parsedSpec.error) };
+    const spec = parsedSpec.data;
+    if (spec.schemaVersion !== SURFACE_SCHEMA_VERSION) {
+        return { ok: false, issues: [{ code: 'unsupported_schema_version', path: '/schemaVersion', message: `Expected ${SURFACE_SCHEMA_VERSION}` }] };
+    }
+    if (spec.catalogVersion !== catalog.version) {
+        return { ok: false, issues: [{ code: 'catalog_version_mismatch', path: '/catalogVersion', message: `Expected ${catalog.version}` }] };
+    }
+    if (spec.dataSources.length > SURFACE_LIMITS.maxDataSources || spec.widgets.length > SURFACE_LIMITS.maxWidgets) {
+        return { ok: false, issues: [{ code: 'limit_exceeded', path: '', message: 'Surface exceeds the source or widget limit' }] };
+    }
+    const duplicateIssue = duplicateIdIssue(spec);
+    if (duplicateIssue)
+        return { ok: false, issues: [duplicateIssue] };
+    for (const [sourceIndex, source] of spec.dataSources.entries()) {
+        const issue = sourcePolicyIssue(source, policy, sourceIndex);
+        if (issue)
+            return { ok: false, issues: [issue] };
+        if ((source.type === 'resource-list' && (source.filters?.length ?? 0) > SURFACE_LIMITS.maxFilters)
+            || (source.type === 'resource-list' && (source.sorters?.length ?? 0) > SURFACE_LIMITS.maxSorters)) {
+            return { ok: false, issues: [{ code: 'limit_exceeded', path: `/dataSources/${sourceIndex}`, message: 'Source exceeds the filter or sorter limit', sourceId: source.id }] };
+        }
+    }
+    const sources = new Map(spec.dataSources.map((source) => [source.id, source]));
+    const definitions = catalogDefinitions(catalog);
+    for (const [widgetIndex, widget] of spec.widgets.entries()) {
+        const issue = widgetIssue(widget, widgetIndex, definitions.get(widget.type), sources, policy);
+        if (issue)
+            return { ok: false, issues: [issue] };
+    }
+    return { ok: true, value: spec };
+}

package/dist/widget-data.d.ts

@@ -0,0 +1,16 @@
+import type { JsonObject, JsonValue } from './types.js';
+export interface SurfaceChartPoint {
+    readonly label: string;
+    readonly value: number;
+}
+export type WidgetValueResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export declare function compactChartLabel(label: string, maxLength: number): string;
+export declare function asRecordArray(value: JsonValue): WidgetValueResult<readonly JsonObject[]>;
+export declare function asChartPoints(value: JsonValue, labelField: string, valueField: string): WidgetValueResult<readonly SurfaceChartPoint[]>;
+export declare function displayTableValue(value: JsonValue | undefined, format: string | undefined): string;

package/dist/widget-data.js

@@ -0,0 +1,41 @@
+export function compactChartLabel(label, maxLength) {
+    const isoDate = /^(?:\d{4})-(\d{2})-(\d{2})$/u.exec(label);
+    if (isoDate)
+        return `${Number(isoDate[1])}/${Number(isoDate[2])}`;
+    const characters = [...label];
+    return characters.length <= maxLength
+        ? label
+        : `${characters.slice(0, Math.max(1, maxLength - 1)).join('')}…`;
+}
+export function asRecordArray(value) {
+    if (!Array.isArray(value))
+        return { ok: false, message: 'Expected a record collection' };
+    const records = value.filter((entry) => (entry !== null && typeof entry === 'object' && !Array.isArray(entry)));
+    return records.length === value.length
+        ? { ok: true, value: records }
+        : { ok: false, message: 'Every collection item must be a record' };
+}
+export function asChartPoints(value, labelField, valueField) {
+    const records = asRecordArray(value);
+    if (!records.ok)
+        return records;
+    const points = [];
+    for (const record of records.value) {
+        const label = record[labelField];
+        const numericValue = record[valueField];
+        if ((typeof label !== 'string' && typeof label !== 'number') || typeof numericValue !== 'number') {
+            return { ok: false, message: `Chart fields "${labelField}" and "${valueField}" have incompatible values` };
+        }
+        points.push({ label: String(label), value: numericValue });
+    }
+    return { ok: true, value: points };
+}
+export function displayTableValue(value, format) {
+    if (value === undefined || value === null)
+        return '—';
+    if (format === 'boolean')
+        return value === true ? 'Yes' : value === false ? 'No' : '—';
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return JSON.stringify(value);
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@svadmin/surface",
+  "version": "0.1.0",
+  "description": "Validated declarative surfaces for svadmin dashboards",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "compatibility.json",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./svelte": {
+      "types": "./dist/svelte.d.ts",
+      "svelte": "./dist/svelte.js",
+      "default": "./dist/svelte.js"
+    }
+  },
+  "peerDependencies": {
+    "@svadmin/core": ">=0.34.2 <0.35.0",
+    "@svadmin/ui": ">=0.40.6 <0.41.0",
+    "svelte": "^5.56.8"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@svadmin/core": "workspace:*",
+    "@svadmin/ui": "workspace:*",
+    "@sveltejs/vite-plugin-svelte": "^7.3.0",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/svelte": "^5.4.2",
+    "@testing-library/user-event": "^14.6.3",
+    "happy-dom": "^20.11.2",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "node ../../node_modules/@sveltejs/package/svelte-package.js -i src -o dist",
+    "check": "svelte-check --tsgo-experimental-api --tsconfig ./tsconfig.json --threshold error",
+    "test": "vitest run --config ./vitest.config.ts"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "author": "zuohuadong",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zuohuadong/svadmin.git",
+    "directory": "packages/surface"
+  },
+  "homepage": "https://github.com/zuohuadong/svadmin#readme",
+  "bugs": {
+    "url": "https://github.com/zuohuadong/svadmin/issues"
+  }
+}