@bilig/workbook 0.107.8 → 0.119.0

package/dist/schema-noop.js

@@ -0,0 +1,128 @@
+import { workbookOpSchema } from './op-schema.js';
+const noopEffectCommandKinds = Object.freeze(['writeValue', 'writeFormula', 'clear', 'format', 'op']);
+function isSchemaObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function schemaConstKind(value) {
+    if (!isSchemaObject(value)) {
+        return undefined;
+    }
+    const properties = value['properties'];
+    if (!isSchemaObject(properties)) {
+        return undefined;
+    }
+    const kind = properties['kind'];
+    if (!isSchemaObject(kind)) {
+        return undefined;
+    }
+    const kindConst = kind['const'];
+    return typeof kindConst === 'string' ? kindConst : undefined;
+}
+function opNoopEffectSchemas(refs) {
+    if (!isSchemaObject(workbookOpSchema) || !Array.isArray(workbookOpSchema['oneOf'])) {
+        return [
+            {
+                type: 'object',
+                required: ['kind', 'opKind', 'op'],
+                additionalProperties: true,
+                properties: {
+                    kind: { const: 'op' },
+                    opKind: refs.exactString,
+                    op: refs.engineOp,
+                },
+            },
+        ];
+    }
+    return workbookOpSchema['oneOf'].map((opSchema) => {
+        const opKind = schemaConstKind(opSchema);
+        return {
+            type: 'object',
+            required: ['kind', 'opKind', 'op'],
+            additionalProperties: true,
+            properties: {
+                kind: { const: 'op' },
+                opKind: opKind === undefined ? refs.exactString : { const: opKind },
+                op: opSchema,
+            },
+        };
+    });
+}
+function noopEffectCommandKindCondition(commandKind) {
+    return {
+        if: {
+            required: ['commandKind', 'noop'],
+            properties: {
+                commandKind: { const: commandKind },
+            },
+        },
+        // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+        then: {
+            properties: {
+                noop: {
+                    properties: {
+                        proof: {
+                            properties: {
+                                commandKind: { const: commandKind },
+                                effect: {
+                                    required: ['kind'],
+                                    properties: {
+                                        kind: { const: commandKind },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+}
+export function createNoopEffectSchema(refs) {
+    return {
+        oneOf: [
+            {
+                type: 'object',
+                required: ['kind', 'value'],
+                additionalProperties: true,
+                properties: {
+                    kind: { const: 'writeValue' },
+                    value: refs.literalInput,
+                },
+            },
+            {
+                type: 'object',
+                required: ['kind', 'formula'],
+                additionalProperties: true,
+                properties: {
+                    kind: { const: 'writeFormula' },
+                    formula: { type: 'string', minLength: 1 },
+                },
+            },
+            {
+                type: 'object',
+                required: ['kind', 'cleared'],
+                additionalProperties: true,
+                properties: {
+                    kind: { const: 'clear' },
+                    cleared: { const: true },
+                },
+            },
+            {
+                type: 'object',
+                required: ['kind'],
+                additionalProperties: true,
+                properties: {
+                    kind: { const: 'format' },
+                    style: refs.actionCellStylePatch,
+                    numberFormat: { oneOf: [{ type: 'string' }, { type: 'null' }] },
+                },
+                anyOf: [{ required: ['style'] }, { required: ['numberFormat'] }],
+            },
+            ...opNoopEffectSchemas(refs),
+        ],
+    };
+}
+export function noopEffectCommandKindConditions() {
+    return noopEffectCommandKinds.map(noopEffectCommandKindCondition);
+}
+//# sourceMappingURL=schema-noop.js.map

package/dist/schema-noop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-noop.js","sourceRoot":"","sources":["../src/schema-noop.ts"],"names":[],"mappings":"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"}

package/dist/schema.js

@@ -1,6 +1,8 @@
 import { workbookRunErrorCodes } from './result.js';
 import { workbookActionInputDescriptionKinds } from './input.js';
 import { cellStylePatchSchema, literalInputSchema, workbookOpSchema } from './op-schema.js';
+import { workbookActionCellStylePatchSchema, workbookCommandReceiptSchema, workbookRefDataDefSchemas, workbookRefDataSchemaRefs, workbookUndoRefSchema, } from './schema-fragments.js';
+import { createNoopEffectSchema, noopEffectCommandKindConditions } from './schema-noop.js';
 export const workbookJsonSchemaVersion = 'bilig-workbook-json-schema-v1';
 export const workbookJsonSchemaNames = Object.freeze([
     'refData',
@@ -19,6 +21,16 @@ const cellRange = Object.freeze({ $ref: '#/$defs/cellRange' });
 const engineOp = Object.freeze({ $ref: '#/$defs/engineOp' });
 const actionInput = Object.freeze({ $ref: '#/$defs/actionInput' });
 const actionInputDescription = Object.freeze({ $ref: '#/$defs/actionInputDescription' });
+const exactString = Object.freeze({
+    type: 'string',
+    minLength: 1,
+    pattern: '^(?!\\s)(?![\\s\\S]*\\s$)[\\s\\S]+$',
+});
+const nonNegativeSafeInteger = Object.freeze({
+    type: 'integer',
+    minimum: 0,
+    maximum: Number.MAX_SAFE_INTEGER,
+});
 function defs(extra = {}) {
     return {
         jsonValue: {
@@ -50,11 +62,11 @@ function defs(extra = {}) {
                 values: { type: 'array', minItems: 1, items: actionInput },
                 min: { type: 'number' },
                 max: { type: 'number' },
-                minLength: { type: 'integer', minimum: 0 },
-                maxLength: { type: 'integer', minimum: 0 },
+                minLength: nonNegativeSafeInteger,
+                maxLength: nonNegativeSafeInteger,
                 pattern: { type: 'string' },
-                minItems: { type: 'integer', minimum: 0 },
-                maxItems: { type: 'integer', minimum: 0 },
+                minItems: nonNegativeSafeInteger,
+                maxItems: nonNegativeSafeInteger,
                 additionalProperties: { type: 'boolean' },
                 default: actionInput,
                 examples: { type: 'array', minItems: 1, items: actionInput },
@@ -97,6 +109,7 @@ function defs(extra = {}) {
             },
         },
         cellStylePatch: cellStylePatchSchema,
+        actionCellStylePatch: workbookActionCellStylePatchSchema,
         formulaLabel: {
             type: 'object',
             required: ['name', 'ref'],
@@ -107,79 +120,9 @@ function defs(extra = {}) {
             },
         },
         engineOp: workbookOpSchema,
+        ...workbookRefDataDefSchemas,
         refData: {
-            oneOf: [
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label', 'range'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'range' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        range: { $ref: '#/$defs/cellRange' },
-                    },
-                },
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label', 'name'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'name' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        name: { type: 'string', minLength: 1 },
-                    },
-                },
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'table' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        name: { type: 'string', minLength: 1 },
-                        sheetName: { type: 'string', minLength: 1 },
-                        headers: { type: 'array', items: { type: 'string' } },
-                    },
-                },
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label', 'table', 'name'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'column' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        table: { $ref: '#/$defs/refData' },
-                        rows: { $ref: '#/$defs/refData' },
-                        name: { type: 'string', minLength: 1 },
-                    },
-                },
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label', 'where'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'rows' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        sheetName: { type: 'string', minLength: 1 },
-                        table: { $ref: '#/$defs/refData' },
-                        where: {
-                            type: 'object',
-                            required: ['column', 'op', 'value'],
-                            additionalProperties: false,
-                            properties: {
-                                column: { type: 'string', minLength: 1 },
-                                op: { enum: ['eq', 'neq', 'contains', 'startsWith', 'gt', 'gte', 'lt', 'lte'] },
-                                value: { $ref: '#/$defs/jsonValue' },
-                            },
-                        },
-                    },
-                },
-            ],
+            oneOf: workbookRefDataSchemaRefs,
         },
         concreteRefData: {
             type: 'object',
@@ -262,15 +205,6 @@ const changeDataSchema = {
         message: { type: 'string', minLength: 1 },
     },
 };
-const undoDataSchema = {
-    type: 'object',
-    required: ['id'],
-    additionalProperties: false,
-    properties: {
-        id: { type: 'string', minLength: 1 },
-        ops: { type: 'array', items: engineOp },
-    },
-};
 const unverifiedDataSchema = {
     type: 'object',
     required: ['kind', 'message'],
@@ -287,9 +221,9 @@ const runtimeRequirementSchema = {
     properties: {
         kind: { enum: ['apply', 'read', 'verify'] },
         capability: { enum: ['writeFormula', 'writeValue', 'format', 'clear', 'applyOp', 'read', 'verifyCheck'] },
-        commandIndex: { type: 'integer', minimum: 0 },
-        checkIndex: { type: 'integer', minimum: 0 },
-        opIndex: { type: 'integer', minimum: 0 },
+        commandIndex: nonNegativeSafeInteger,
+        checkIndex: nonNegativeSafeInteger,
+        opIndex: nonNegativeSafeInteger,
         opKind: { type: 'string', minLength: 1 },
         checkKind: { type: 'string', minLength: 1 },
         target: refData,
@@ -321,8 +255,8 @@ const applySummarySchema = {
     properties: {
         matched: { oneOf: [{ type: 'boolean' }, { type: 'null' }] },
         planId: { type: 'string', minLength: 1 },
-        baseRevision: { type: 'integer', minimum: 0 },
-        revision: { type: 'integer', minimum: 0 },
+        baseRevision: nonNegativeSafeInteger,
+        revision: nonNegativeSafeInteger,
         previewOps: { type: 'array', items: engineOp },
         appliedOps: { type: 'array', items: engineOp },
         commandReceipts: { type: 'array', items: { $ref: '#/$defs/applyCommandReceipt' } },
@@ -334,11 +268,33 @@ const applyCommandReceiptSchema = {
     required: ['commandIndex', 'commandKind', 'commandDigest', 'previewOps', 'appliedOps'],
     additionalProperties: false,
     properties: {
-        commandIndex: { type: 'integer', minimum: 0 },
+        commandIndex: nonNegativeSafeInteger,
         commandKind: { type: 'string', minLength: 1 },
         commandDigest: { type: 'string', minLength: 1 },
         previewOps: { type: 'array', items: engineOp },
         appliedOps: { type: 'array', items: engineOp },
+        noop: {
+            type: 'object',
+            required: ['reason', 'proof'],
+            additionalProperties: false,
+            properties: {
+                reason: { enum: ['already_satisfied'] },
+                message: { type: 'string', minLength: 1 },
+                proof: {
+                    type: 'object',
+                    required: ['source', 'evidence', 'opCount', 'commandKind', 'commandDigest', 'effect'],
+                    additionalProperties: true,
+                    properties: {
+                        source: exactString,
+                        evidence: exactString,
+                        opCount: { const: 0 },
+                        commandKind: exactString,
+                        commandDigest: exactString,
+                        effect: { $ref: '#/$defs/noopEffect' },
+                    },
+                },
+            },
+        },
         resolvedRefs: { $ref: '#/$defs/commandResolvedRefs' },
         formulaLabels: {
             type: 'array',
@@ -354,6 +310,19 @@ const applyCommandReceiptSchema = {
         },
         proof: actionInput,
     },
+    allOf: [
+        {
+            if: { required: ['noop'] },
+            // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+            then: {
+                properties: {
+                    previewOps: { type: 'array', maxItems: 0, items: engineOp },
+                    appliedOps: { type: 'array', maxItems: 0, items: engineOp },
+                },
+            },
+        },
+        ...noopEffectCommandKindConditions(),
+    ],
 };
 export const workbookJsonSchemas = deepFreeze({
     refData: schema('refData', {
@@ -415,9 +384,10 @@ export const workbookJsonSchemas = deepFreeze({
                         properties: {
                             kind: { const: 'format' },
                             target: refData,
-                            style: { $ref: '#/$defs/cellStylePatch' },
+                            style: { $ref: '#/$defs/actionCellStylePatch' },
                             numberFormat: { oneOf: [{ type: 'string' }, { type: 'null' }] },
                         },
+                        anyOf: [{ required: ['style'] }, { required: ['numberFormat'] }],
                     },
                     {
                         type: 'object',
@@ -474,8 +444,8 @@ export const workbookJsonSchemas = deepFreeze({
                 required: ['featureId', 'commandId'],
                 additionalProperties: false,
                 properties: {
-                    featureId: { type: 'string', minLength: 1 },
-                    commandId: { type: 'string', minLength: 1 },
+                    featureId: exactString,
+                    commandId: exactString,
                     category: { enum: ['command', 'operation', 'mutation'] },
                     mode: { enum: ['preview', 'apply', 'applyAndVerify'] },
                     input: actionInput,
@@ -489,21 +459,57 @@ export const workbookJsonSchemas = deepFreeze({
                         additionalProperties: false,
                         properties: {
                             kind: { const: 'request' },
-                            id: { type: 'string', minLength: 1 },
+                            id: exactString,
                             touchedRanges: { type: 'array', items: cellRange },
                             destructive: { type: 'boolean' },
                             request: { $ref: '#/$defs/commandRequest' },
                         },
+                        allOf: [
+                            {
+                                if: {
+                                    properties: {
+                                        request: {
+                                            type: 'object',
+                                            properties: { category: { const: 'mutation' } },
+                                            required: ['category'],
+                                        },
+                                    },
+                                    required: ['request'],
+                                },
+                                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                then: {
+                                    required: ['destructive'],
+                                    properties: { destructive: { const: true } },
+                                },
+                            },
+                            {
+                                if: {
+                                    properties: {
+                                        request: {
+                                            type: 'object',
+                                            properties: { mode: { enum: ['apply', 'applyAndVerify'] } },
+                                            required: ['mode'],
+                                        },
+                                    },
+                                    required: ['request'],
+                                },
+                                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                then: {
+                                    required: ['destructive'],
+                                    properties: { destructive: { const: true } },
+                                },
+                            },
+                        ],
                     },
                     {
                         type: 'object',
-                        required: ['kind', 'op'],
+                        required: ['kind', 'destructive', 'op'],
                         additionalProperties: false,
                         properties: {
                             kind: { const: 'op' },
-                            id: { type: 'string', minLength: 1 },
+                            id: exactString,
                             touchedRanges: { type: 'array', items: cellRange },
-                            destructive: { type: 'boolean' },
+                            destructive: { const: true },
                             op: engineOp,
                         },
                     },
@@ -514,60 +520,151 @@ export const workbookJsonSchemas = deepFreeze({
         required: ['targetRevision', 'idempotencyKey', 'commands'],
         additionalProperties: false,
         properties: {
-            id: { type: 'string', minLength: 1 },
-            targetRevision: { type: 'integer', minimum: 0 },
-            idempotencyKey: { type: 'string', minLength: 1 },
+            id: exactString,
+            targetRevision: nonNegativeSafeInteger,
+            idempotencyKey: exactString,
             scope: {
                 type: 'object',
                 additionalProperties: false,
-                properties: { maxTouchedCells: { type: 'integer', minimum: 0 } },
+                properties: { maxTouchedCells: nonNegativeSafeInteger },
             },
             commands: { type: 'array', minItems: 1, items: { $ref: '#/$defs/bundleCommand' } },
         },
+        allOf: [
+            {
+                if: {
+                    properties: {
+                        scope: {
+                            type: 'object',
+                            required: ['maxTouchedCells'],
+                        },
+                    },
+                    required: ['scope'],
+                },
+                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                then: {
+                    properties: {
+                        commands: {
+                            items: {
+                                allOf: [
+                                    {
+                                        if: {
+                                            properties: { kind: { const: 'op' } },
+                                            required: ['kind'],
+                                        },
+                                        // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                        then: {
+                                            required: ['touchedRanges'],
+                                            properties: { touchedRanges: { type: 'array', minItems: 1, items: cellRange } },
+                                        },
+                                    },
+                                    {
+                                        if: {
+                                            properties: {
+                                                kind: { const: 'request' },
+                                                request: {
+                                                    type: 'object',
+                                                    properties: { category: { const: 'mutation' } },
+                                                    required: ['category'],
+                                                },
+                                            },
+                                            required: ['kind', 'request'],
+                                        },
+                                        // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                        then: {
+                                            required: ['touchedRanges'],
+                                            properties: { touchedRanges: { type: 'array', minItems: 1, items: cellRange } },
+                                        },
+                                    },
+                                    {
+                                        if: {
+                                            properties: {
+                                                kind: { const: 'request' },
+                                                request: {
+                                                    type: 'object',
+                                                    properties: { mode: { enum: ['apply', 'applyAndVerify'] } },
+                                                    required: ['mode'],
+                                                },
+                                            },
+                                            required: ['kind', 'request'],
+                                        },
+                                        // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                        then: {
+                                            required: ['touchedRanges'],
+                                            properties: { touchedRanges: { type: 'array', minItems: 1, items: cellRange } },
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+        ],
     }),
     commandResult: schema('commandResult', {
         $defs: defs({
-            receipt: {
-                type: 'object',
-                required: ['status', 'featureId', 'commandId', 'category'],
-                properties: {
-                    status: { enum: ['previewed', 'applied', 'rejected', 'noop'] },
-                    featureId: { type: 'string', minLength: 1 },
-                    commandId: { type: 'string', minLength: 1 },
-                    category: { enum: ['command', 'operation', 'mutation'] },
-                    previewOps: { type: 'array', items: engineOp },
-                    appliedOps: { type: 'array', items: engineOp },
-                    undo: { type: 'object', additionalProperties: true },
-                    changedRanges: { type: 'array', items: cellRange },
-                    proof: actionInput,
-                    message: { type: 'string' },
-                    metadata: actionInput,
-                    errors: { type: 'array', items: { type: 'string' } },
-                },
-                additionalProperties: false,
-            },
+            undo: workbookUndoRefSchema,
+            receipt: workbookCommandReceiptSchema,
         }),
         type: 'object',
         required: ['status', 'targetRevision', 'idempotencyKey', 'commandCount', 'touchedRanges', 'touchedCellCount'],
         additionalProperties: false,
         properties: {
             status: { enum: ['accepted', 'previewed', 'applied', 'rejected', 'noop'] },
-            bundleId: { type: 'string', minLength: 1 },
-            targetRevision: { type: 'integer', minimum: 0 },
-            idempotencyKey: { type: 'string', minLength: 1 },
-            commandCount: { type: 'integer', minimum: 0 },
+            bundleId: exactString,
+            targetRevision: nonNegativeSafeInteger,
+            idempotencyKey: exactString,
+            commandCount: nonNegativeSafeInteger,
             touchedRanges: { type: 'array', items: cellRange },
-            touchedCellCount: { type: 'integer', minimum: 0 },
+            touchedCellCount: nonNegativeSafeInteger,
             receipts: { type: 'array', items: { $ref: '#/$defs/receipt' } },
             matched: { oneOf: [{ type: 'boolean' }, { type: 'null' }] },
             changedRanges: { type: 'array', items: cellRange },
-            revision: { type: 'integer', minimum: 0 },
-            undo: { type: 'object', additionalProperties: true },
-            errors: { type: 'array', items: { type: 'string' } },
+            revision: nonNegativeSafeInteger,
+            undo: { $ref: '#/$defs/undo' },
+            errors: { type: 'array', items: exactString },
         },
+        allOf: [
+            {
+                if: { properties: { status: { const: 'accepted' } }, required: ['status'] },
+                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                then: {
+                    not: {
+                        anyOf: [
+                            { required: ['receipts'] },
+                            { required: ['matched'] },
+                            { required: ['changedRanges'] },
+                            { required: ['revision'] },
+                            { required: ['undo'] },
+                            { required: ['errors'] },
+                        ],
+                    },
+                },
+            },
+            {
+                if: {
+                    properties: { status: { enum: ['previewed', 'applied', 'rejected', 'noop'] } },
+                    required: ['status'],
+                },
+                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                then: {
+                    required: ['receipts', 'matched', 'changedRanges'],
+                    properties: {
+                        receipts: { type: 'array', minItems: 1, items: { $ref: '#/$defs/receipt' } },
+                    },
+                },
+            },
+        ],
     }),
     runResult: schema('runResult', {
         $defs: defs({
+            noopEffect: createNoopEffectSchema({
+                literalInput,
+                exactString,
+                engineOp,
+                actionCellStylePatch: { $ref: '#/$defs/actionCellStylePatch' },
+            }),
             checkExpectation: checkExpectationSchema,
             apply: applySummarySchema,
             applyCommandReceipt: applyCommandReceiptSchema,
@@ -584,7 +681,7 @@ export const workbookJsonSchemas = deepFreeze({
                     issueCode: { type: 'string' },
                 },
             },
-            undo: undoDataSchema,
+            undo: workbookUndoRefSchema,
             unverified: unverifiedDataSchema,
         }),
         oneOf: [