@script-it/json-views-core 0.1.0-beta.1

package/dist/view-model.js

@@ -0,0 +1,134 @@
+import { inferJsonViewRecordTitleKey } from './inference.js';
+import { inferFlatColumnPaths } from './table-suitability.js';
+import { compareJsonValues, jsonValuesEqual, matchesJsonValueFilter } from './value-comparison.js';
+import { JSON_VIEW_PATH_MISSING, getJsonViewViewRows, matchesJsonViewPath, resolveJsonViewRowPath, schemaForJsonViewPath, } from './metadata.js';
+import { defaultTypeRegistry } from './type-registry.js';
+export function matchesJsonViewFilterRule(value, rule, descriptor, typeRegistry = defaultTypeRegistry, context = {}) {
+    if (descriptor) {
+        const typed = typeRegistry.matchesFilter(value, rule.operator, rule.value, descriptor);
+        if (typed !== undefined)
+            return typed;
+    }
+    if (value === JSON_VIEW_PATH_MISSING)
+        return rule.operator === 'isEmpty';
+    return matchesJsonValueFilter(value, rule.operator, rule.value, context);
+}
+function filteredRows(root, rows, view, schema, typeRegistry, numberAtPath) {
+    const filter = view.filter;
+    if (!filter || filter.rules.length === 0)
+        return rows;
+    return rows.filter((row) => {
+        const matches = filter.rules.map((rule) => {
+            const resolved = resolveJsonViewRowPath(root, row, rule.path);
+            const descriptor = schemaForJsonViewPath(schema, resolved.sourcePath)?.descriptor;
+            return matchesJsonViewFilterRule(resolved.value, rule, descriptor, typeRegistry, { numberAtPath, leftPath: resolved.sourcePath, rightPath: rule.sourceValuePath });
+        });
+        return filter.match === 'all' ? matches.every(Boolean) : matches.some(Boolean);
+    });
+}
+function compare(left, right, direction, descriptor, typeRegistry, context) {
+    if (jsonValuesEqual(left, right, context))
+        return 0;
+    if (left === JSON_VIEW_PATH_MISSING || left == null)
+        return 1;
+    if (right === JSON_VIEW_PATH_MISSING || right == null)
+        return -1;
+    const typed = descriptor ? typeRegistry.compare(left, right, descriptor, direction) : undefined;
+    if (typed !== undefined)
+        return typed;
+    const result = compareJsonValues(left, right, context);
+    return direction === 'desc' ? -result : result;
+}
+function sortedRows(root, rows, view, schema, typeRegistry, numberAtPath) {
+    if (view.sort.length === 0)
+        return rows;
+    const prepared = rows.map((row, index) => ({
+        row, index,
+        fields: view.sort.map((sort) => {
+            const resolved = resolveJsonViewRowPath(root, row, sort.path);
+            return { value: resolved.value, sourcePath: resolved.sourcePath, descriptor: schemaForJsonViewPath(schema, resolved.sourcePath)?.descriptor };
+        }),
+    }));
+    // Each column uses one comparator for every pair, including mixed-type annotations.
+    const descriptors = view.sort.map((_, index) => {
+        const defined = prepared.map((item) => item.fields[index].descriptor).filter((item) => item !== undefined);
+        return new Set(defined.map((item) => item.type)).size === 1 ? defined[0] : undefined;
+    });
+    return prepared.sort((left, right) => {
+        for (let index = 0; index < view.sort.length; index += 1) {
+            const result = compare(left.fields[index].value, right.fields[index].value, view.sort[index].direction, descriptors[index], typeRegistry, { numberAtPath, leftPath: left.fields[index].sourcePath, rightPath: right.fields[index].sourcePath });
+            if (result !== 0)
+                return result;
+        }
+        return left.index - right.index;
+    }).map(({ row }) => row);
+}
+export function applyJsonViewViewRows(root, view, schema = [], typeRegistry = defaultTypeRegistry, numberAtPath) {
+    return sortedRows(root, filteredRows(root, getJsonViewViewRows(view, root), view, schema, typeRegistry, numberAtPath), view, schema, typeRegistry, numberAtPath);
+}
+function inferredViewProperty(view, key) {
+    const escaped = key
+        .replace(/\\/g, '\\\\')
+        .replace(/'/g, "\\'")
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+    return {
+        source: `${view.path.source}[*]['${escaped}']`,
+        root: '$',
+        segments: [...view.path.segments, { kind: 'wildcard' }, { kind: 'property', key }],
+    };
+}
+function inferredColumns(view, rows) {
+    const titleKey = inferJsonViewRecordTitleKey(rows.map((row) => row.value));
+    const flattened = inferFlatColumnPaths(rows.map((row) => row.value));
+    if (flattened && titleKey)
+        flattened.sort((a, b) => Number(b.length === 1 && b[0] === titleKey) - Number(a.length === 1 && a[0] === titleKey));
+    if (flattened)
+        return flattened.map((parts, index) => {
+            const path = inferredViewProperty(view, parts[0]);
+            for (const key of parts.slice(1)) {
+                path.segments.push({ kind: 'property', key });
+                path.source += `[${JSON.stringify(key)}]`;
+            }
+            return { label: parts.join(' · '), path, metadataPath: ['__inferred_columns__', index] };
+        });
+    const keys = new Set();
+    rows.forEach((row) => Object.keys(row.value).forEach((key) => keys.add(key)));
+    return Array.from(keys).sort((a, b) => Number(b === titleKey) - Number(a === titleKey)).map((key, index) => ({
+        label: key,
+        path: inferredViewProperty(view, key),
+        metadataPath: ['__inferred_columns__', index],
+    }));
+}
+export function projectJsonViewCollection(root, view, schema = [], typeRegistry = defaultTypeRegistry, numberAtPath) {
+    const rows = applyJsonViewViewRows(root, view, schema, typeRegistry, numberAtPath);
+    const declared = view.columns ?? inferredColumns(view, rows);
+    const columns = declared.map((column, index) => ({
+        id: `column-${index}`,
+        label: column.label,
+        path: column.path,
+    }));
+    const records = rows.map((row) => Object.fromEntries(columns.flatMap((column) => {
+        const resolved = resolveJsonViewRowPath(root, row, column.path).value;
+        return resolved === JSON_VIEW_PATH_MISSING ? [] : [[column.id, resolved]];
+    })));
+    return { rows, columns, records };
+}
+export function schemaRelativePathForRow(schema, rowPath) {
+    if (schema.path.segments.length <= rowPath.length)
+        return undefined;
+    if (!matchesJsonViewPath({ ...schema.path, segments: schema.path.segments.slice(0, rowPath.length) }, rowPath))
+        return undefined;
+    const remainder = schema.path.segments.slice(rowPath.length);
+    if (remainder.some((segment) => segment.kind === 'wildcard'))
+        return undefined;
+    const relativePath = [];
+    for (const segment of remainder) {
+        if (segment.kind === 'property')
+            relativePath.push(segment.key);
+        else if (segment.kind === 'index')
+            relativePath.push(segment.index);
+    }
+    return relativePath;
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@script-it/json-views-core",
+  "version": "0.1.0-beta.1",
+  "description": "JSON Views metadata, path, validation, and source-preserving editing core",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schema.json": "./schema/jsonviews.schema.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "schema",
+    "THIRD_PARTY_NOTICES.txt"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/clean-dist.mjs && tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "prepack": "node ../../scripts/prepare-package.mjs"
+  },
+  "devDependencies": {
+    "ajv": "^8.20.0",
+    "typescript": "^5.9.3",
+    "vitest": "3.2.7"
+  },
+  "dependencies": {
+    "re2js": "^2.8.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/script-it/json-views.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/script-it/json-views#readme",
+  "bugs": {
+    "url": "https://github.com/script-it/json-views/issues"
+  },
+  "engines": {
+    "node": "^22.13.0 || >=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/schema/jsonviews.schema.json

@@ -0,0 +1,102 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://raw.githubusercontent.com/script-it/json-views/main/packages/core/schema/jsonviews.schema.json",
+  "title": "JSON Views annotation metadata, version 1",
+  "description": "Validates the annotation object passed externally or stored under $jsonviews. This is not a JSON Schema for the annotated document. JSONPath resolution, registered types, RE2 patterns, date validity, and view compatibility are checked by the compiler.",
+  "type": "object",
+  "required": ["version"],
+  "properties": {
+    "version": { "const": 1 },
+    "schema": {
+      "type": "object",
+      "propertyNames": { "$ref": "#/definitions/path" },
+      "additionalProperties": { "$ref": "#/definitions/descriptor" }
+    },
+    "views": { "type": "array", "items": { "$ref": "#/definitions/view" } }
+  },
+  "additionalProperties": true,
+  "definitions": {
+    "path": { "type": "string", "pattern": "^\\$", "description": "Absolute JSON Views path; the compiler checks the supported JSONPath subset and wildcard placement." },
+    "label": { "type": "string", "pattern": "\\S" },
+    "descriptor": {
+      "type": "object",
+      "required": ["type"],
+      "properties": {
+        "type": { "$ref": "#/definitions/label" },
+        "title": { "type": "string" },
+        "description": { "type": "string" },
+        "required": { "type": "boolean" },
+        "nullable": false,
+        "minimum": { "type": ["number", "string", "null"] },
+        "maximum": { "type": ["number", "string", "null"] },
+        "defaultIncludeTime": { "type": "boolean" },
+        "pattern": { "type": "string", "maxLength": 4096, "description": "RE2 syntax, tested as an unanchored search; unsupported constructs are compiler diagnostics." },
+        "options": { "type": "array", "items": { "type": "string" } },
+        "optionColors": {
+          "type": "object",
+          "additionalProperties": { "enum": ["gray", "blue", "green", "yellow", "orange", "red", "purple", "pink"] },
+          "description": "Optional palette color for each select or multi-select option."
+        },
+        "placeholder": { "type": "string" },
+        "multiline": { "type": "boolean" },
+        "step": { "type": "number", "exclusiveMinimum": 0 }
+      },
+      "if": { "properties": { "type": { "const": "date" } }, "required": ["type"] },
+      "then": { "properties": { "minimum": { "type": ["string", "null"] }, "maximum": { "type": ["string", "null"] } } },
+      "else": { "properties": { "minimum": { "type": "number" }, "maximum": { "type": "number" } } },
+      "additionalProperties": true
+    },
+    "column": {
+      "type": "object",
+      "required": ["label", "path"],
+      "properties": { "label": { "$ref": "#/definitions/label" }, "path": { "$ref": "#/definitions/path" } },
+      "additionalProperties": true
+    },
+    "filterRule": {
+      "type": "object",
+      "required": ["path", "operator"],
+      "properties": { "path": { "$ref": "#/definitions/path" }, "operator": { "$ref": "#/definitions/label" }, "value": {} },
+      "allOf": [
+        {
+          "if": { "properties": { "operator": { "enum": ["isEmpty", "isNotEmpty"] } }, "required": ["operator"] },
+          "else": { "required": ["value"] }
+        },
+        {
+          "if": { "properties": { "operator": { "enum": ["in", "notIn"] } }, "required": ["operator"] },
+          "then": { "properties": { "value": { "type": "array" } } }
+        }
+      ],
+      "additionalProperties": true
+    },
+    "filter": {
+      "type": "object",
+      "required": ["rules"],
+      "properties": { "match": { "enum": ["all", "any"] }, "rules": { "type": "array", "items": { "$ref": "#/definitions/filterRule" } } },
+      "additionalProperties": true
+    },
+    "sort": {
+      "type": "object",
+      "required": ["path", "direction"],
+      "properties": { "path": { "$ref": "#/definitions/path" }, "direction": { "enum": ["asc", "desc"] } },
+      "additionalProperties": true
+    },
+    "view": {
+      "type": "object",
+      "required": ["name", "path"],
+      "properties": {
+        "id": { "type": "string" },
+        "name": { "$ref": "#/definitions/label" },
+        "path": { "$ref": "#/definitions/path" },
+        "display": { "enum": ["kanban", "html"], "description": "Omit for automatic record/collection layout." },
+        "title": false,
+        "groupBy": { "$ref": "#/definitions/path" },
+        "groupOrder": { "type": "array", "items": { "type": ["string", "number", "boolean", "null"] }, "uniqueItems": true },
+        "orderPath": { "$ref": "#/definitions/path" },
+        "columns": { "type": "array", "items": { "$ref": "#/definitions/column" } },
+        "filter": { "$ref": "#/definitions/filter" },
+        "sort": { "type": "array", "items": { "$ref": "#/definitions/sort" } }
+      },
+      "additionalProperties": true
+    }
+  }
+}