Highly ambitious ATProtocol AppView service and sdks
fix lexicon intellisense build
+602
-633
+1
-2
deno.json
+1
-2
deno.json
···
12
12
"dev:cli": "deno run --allow-all packages/cli/src/mod.ts",
13
13
"build:cli": "cd packages/cli && deno compile --allow-all --output bin/slices src/mod.ts",
14
14
"build:lexicon": "cd packages/lexicon && deno task build",
15
+
"build:lexicon-intellisense": "cd ./packages/lexicon-rs && wasm-pack build --target web --features wasm && cp pkg/* ../lexicon-intellisense/wasm/",
15
16
"codegen:cli": "deno task dev:cli codegen --lexicons ./lexicons --slice at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z --output ./packages/cli/src/generated_client.ts --include-slices",
16
17
"codegen:frontend": "deno task dev:cli codegen --lexicons ./lexicons --slice at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z --output ./frontend/src/client.ts --include-slices",
17
18
"dev:frontend": "cd frontend && deno task dev",
18
-
"build:lexicon-intellisense-wasm": "cd ./packages/lexicon-rs && wasm-pack build --target web --features wasm && cp pkg/* ../lexicon-intellisense/wasm/",
19
-
"build:lexicon-intellisense-lexicon": "deno bundle ./packages/lexicon/mod.ts -o ./packages/lexicon-intellisense/src/slices_lexicon.js",
20
19
"test": "deno test --allow-all packages/*/tests/ packages/*/src/ frontend/src/",
21
20
"check": "deno check packages/*/src/ packages/*/mod.ts packages/*/src/mod.ts frontend/src/**/*.ts frontend/src/**/*.tsx",
22
21
"fmt": "deno fmt packages/ frontend/",
+2
-2
packages/lexicon-intellisense/package.json
+2
-2
packages/lexicon-intellisense/package.json
···
1
1
{
2
2
"name": "lexicon-intellisense",
3
-
"version": "0.2.0",
3
+
"version": "0.2.1",
4
4
"description": "VS Code IntelliSense support for AT Protocol lexicon JSON files",
5
5
"main": "./out/extension.js",
6
6
"license": "MIT",
···
59
59
}
60
60
},
61
61
"scripts": {
62
-
"compile": "tsc -p ./",
62
+
"compile": "rm -rf ./out && tsc -p ./",
63
63
"watch": "tsc -watch -p ./"
64
64
},
65
65
"devDependencies": {
+29
-34
packages/lexicon-intellisense/src/language-server.ts
+29
-34
packages/lexicon-intellisense/src/language-server.ts
···
7
7
ServerOptions,
8
8
TransportKind,
9
9
} from "vscode-languageclient/node";
10
-
// @ts-ignore - No declaration file for bundled module
11
10
import {
12
11
LexiconValidator,
13
12
ValidationError,
14
13
validate,
15
14
validateWithDetails,
16
-
// @ts-ignore
17
-
} from "./slices_lexicon.js";
18
-
19
-
// Type definitions for lexicon documents
20
-
interface LexiconDoc {
21
-
id: string;
22
-
defs: Record<string, unknown>;
23
-
lexicon?: number;
24
-
}
15
+
type LexiconDoc,
16
+
} from "./lexicon";
25
17
26
18
export class LexiconLanguageServer {
27
19
private client: LanguageClient | undefined;
···
186
178
const lexicon = JSON.parse(content);
187
179
console.log(lexicon.id, "loaded from", filePath);
188
180
if (lexicon.id && lexicon.defs) {
189
-
lexicons.push(lexicon as LexiconDoc);
181
+
lexicons.push(lexicon);
190
182
idToFileMap.set(lexicon.id, filePath);
191
183
}
192
184
} catch (error) {
···
204
196
// Attribute errors to specific files
205
197
if (errorsByLexiconId) {
206
198
for (const [lexiconId, errors] of Object.entries(errorsByLexiconId)) {
207
-
const filePath = idToFileMap.get(lexiconId);
208
-
if (filePath) {
209
-
const uri = vscode.Uri.file(filePath);
210
-
const existingDiagnostics =
211
-
this.diagnosticCollection.get(uri) || [];
212
-
const diagnostics = [...existingDiagnostics];
199
+
const filePath = idToFileMap.get(lexiconId);
200
+
if (filePath) {
201
+
const uri = vscode.Uri.file(filePath);
202
+
const existingDiagnostics =
203
+
this.diagnosticCollection.get(uri) || [];
204
+
const diagnostics = [...existingDiagnostics];
213
205
214
-
// Add each error as a diagnostic
215
-
for (const error of errors as string[]) {
216
-
diagnostics.push(
217
-
this.createDiagnostic(
218
-
new vscode.Range(0, 0, 0, 0),
219
-
error,
220
-
vscode.DiagnosticSeverity.Error
221
-
)
222
-
);
206
+
// Add each error as a diagnostic
207
+
for (const error of errors as string[]) {
208
+
diagnostics.push(
209
+
this.createDiagnostic(
210
+
new vscode.Range(0, 0, 0, 0),
211
+
error,
212
+
vscode.DiagnosticSeverity.Error
213
+
)
214
+
);
215
+
}
216
+
217
+
this.diagnosticCollection.set(uri, diagnostics);
223
218
}
224
-
225
-
this.diagnosticCollection.set(uri, diagnostics);
226
-
}
227
219
}
228
220
}
229
221
230
-
const totalErrors = errorsByLexiconId ? Object.values(errorsByLexiconId).reduce(
231
-
(sum: number, errors) => sum + (errors as string[]).length,
232
-
0
233
-
) : 0;
222
+
const totalErrors = errorsByLexiconId
223
+
? Object.values(errorsByLexiconId).reduce(
224
+
(sum: number, errors) => sum + (errors as string[]).length,
225
+
0
226
+
)
227
+
: 0;
234
228
if (totalErrors === 0) {
235
229
console.log(
236
230
`Successfully validated ${lexicons.length} lexicon files`
237
231
);
238
232
} else {
233
+
const errorCount = errorsByLexiconId ? Object.keys(errorsByLexiconId).length : 0;
239
234
console.log(
240
-
`Validation found ${totalErrors} errors across ${errorsByLexiconId.size} lexicons`
235
+
`Validation found ${totalErrors} errors across ${errorCount} lexicons`
241
236
);
242
237
}
243
238
} catch (error) {
+570
packages/lexicon-intellisense/src/lexicon.ts
+570
packages/lexicon-intellisense/src/lexicon.ts
···
1
+
/**
2
+
* AT Protocol Lexicon Validation Library
3
+
*
4
+
* Core implementation for comprehensive validation of AT Protocol lexicon documents and data records.
5
+
* Built on WebAssembly for high performance validation with full AT Protocol compliance.
6
+
*/
7
+
8
+
import init, {
9
+
WasmLexiconValidator,
10
+
validate_string_format,
11
+
is_valid_nsid,
12
+
validate_lexicons_and_get_errors,
13
+
} from "../wasm/slices_lexicon.js";
14
+
15
+
// ============================================================================
16
+
// Module Initialization
17
+
// ============================================================================
18
+
19
+
/** Global WASM initialization state */
20
+
let wasmInitialized = false;
21
+
let wasmInitPromise: Promise<void> | null = null;
22
+
23
+
/**
24
+
* Ensures the WebAssembly module is properly initialized before use.
25
+
* This is called automatically by all public methods.
26
+
*
27
+
* @internal
28
+
*/
29
+
export async function ensureWasmInit(): Promise<void> {
30
+
if (!wasmInitialized) {
31
+
if (!wasmInitPromise) {
32
+
wasmInitPromise = (async () => {
33
+
// Try to load WASM file - works in both Node.js and browser contexts
34
+
try {
35
+
// In Node.js (VS Code extension), use fs to load the file
36
+
if (typeof process !== 'undefined' && process.versions && process.versions.node) {
37
+
const fs = require('fs');
38
+
const path = require('path');
39
+
40
+
// Use __dirname which is available in CommonJS
41
+
const wasmPath = path.join(__dirname, '../wasm/slices_lexicon_bg.wasm');
42
+
const wasmBuffer = fs.readFileSync(wasmPath);
43
+
await init({ module_or_path: wasmBuffer });
44
+
} else {
45
+
// In browser, fetch the WASM file
46
+
const wasmPath = '../wasm/slices_lexicon_bg.wasm';
47
+
const response = await fetch(wasmPath);
48
+
const wasmBuffer = await response.arrayBuffer();
49
+
await init({ module_or_path: wasmBuffer });
50
+
}
51
+
wasmInitialized = true;
52
+
} catch (error) {
53
+
wasmInitPromise = null; // Reset so we can retry
54
+
throw error;
55
+
}
56
+
})();
57
+
}
58
+
await wasmInitPromise;
59
+
}
60
+
}
61
+
62
+
// ============================================================================
63
+
// Types and Interfaces
64
+
// ============================================================================
65
+
66
+
/**
67
+
* Custom error class for lexicon validation failures.
68
+
* Extends the native Error class with validation-specific context.
69
+
*/
70
+
export class ValidationError extends Error {
71
+
/**
72
+
* Creates a new ValidationError instance.
73
+
*
74
+
* @param message - Human-readable error description
75
+
*/
76
+
constructor(message: string) {
77
+
super(message);
78
+
this.name = "ValidationError";
79
+
}
80
+
}
81
+
82
+
/**
83
+
* Represents a complete AT Protocol lexicon document.
84
+
* Contains schema definitions and metadata for a specific collection or service.
85
+
*/
86
+
export interface LexiconDoc {
87
+
/** Unique namespace identifier (NSID) for this lexicon */
88
+
id: string;
89
+
90
+
/** Schema definitions mapping definition names to their schemas */
91
+
defs: Record<string, LexiconDefinition>;
92
+
93
+
/** Lexicon format version (currently 1) */
94
+
lexicon?: number;
95
+
}
96
+
97
+
/**
98
+
* Base lexicon definition interface
99
+
*/
100
+
export interface LexiconDefinition {
101
+
type: string;
102
+
description?: string;
103
+
[key: string]: unknown; // Allow additional properties
104
+
}
105
+
106
+
/**
107
+
* String format types supported by AT Protocol
108
+
*/
109
+
export type StringFormat =
110
+
| "datetime"
111
+
| "uri"
112
+
| "at-uri"
113
+
| "did"
114
+
| "handle"
115
+
| "at-identifier"
116
+
| "nsid"
117
+
| "cid"
118
+
| "language"
119
+
| "tid"
120
+
| "record-key";
121
+
122
+
/**
123
+
* Type alias for validation error results
124
+
*/
125
+
export type ValidationErrors = Record<string, string[]> | null;
126
+
127
+
/**
128
+
* Comprehensive validation result with error details and statistics.
129
+
*/
130
+
export interface ValidationResult {
131
+
/** Whether all lexicons passed validation */
132
+
valid: boolean;
133
+
134
+
/** Map of lexicon IDs to their error messages */
135
+
errors: Record<string, string[]>;
136
+
137
+
/** Total count of all validation errors across all lexicons */
138
+
totalErrors: number;
139
+
140
+
/** Number of lexicons that have validation errors */
141
+
lexiconsWithErrors: number;
142
+
}
143
+
144
+
/**
145
+
* Detailed error context information for debugging validation failures.
146
+
*/
147
+
export interface ErrorContext {
148
+
/** Current path in the schema being validated */
149
+
path: string;
150
+
151
+
/** ID of the lexicon currently being validated */
152
+
current_lexicon: string | null;
153
+
154
+
/** Whether a circular reference was detected */
155
+
has_circular_reference: boolean;
156
+
157
+
/** Stack of references being resolved (for circular detection) */
158
+
reference_stack: string[];
159
+
}
160
+
161
+
// ============================================================================
162
+
// Core Validator Class
163
+
// ============================================================================
164
+
165
+
/**
166
+
* High-performance AT Protocol lexicon validator with resource management.
167
+
*
168
+
* Provides comprehensive validation capabilities including:
169
+
* - Schema structure validation
170
+
* - Cross-reference resolution
171
+
* - Data format validation
172
+
* - Circular dependency detection
173
+
*
174
+
* Implements Disposable for automatic resource cleanup.
175
+
*/
176
+
export class LexiconValidator implements Disposable {
177
+
private wasmValidator: WasmLexiconValidator;
178
+
179
+
/**
180
+
* Creates a new validator instance with the provided lexicon documents.
181
+
*
182
+
* Note: Prefer using the static `create()` method for async initialization.
183
+
*
184
+
* @param lexicons - Array of lexicon documents to validate
185
+
*/
186
+
constructor(lexicons: LexiconDoc[]) {
187
+
const lexiconsJson = JSON.stringify(lexicons);
188
+
this.wasmValidator = new WasmLexiconValidator(lexiconsJson);
189
+
}
190
+
191
+
/**
192
+
* Creates a new validator instance with proper async initialization.
193
+
* Ensures WASM module is loaded before creating the validator.
194
+
*
195
+
* @param lexicons - Array of lexicon documents to validate
196
+
* @returns Promise resolving to a new validator instance
197
+
*
198
+
* @example
199
+
* ```typescript
200
+
* const lexicons = [{ id: "com.example.post", defs: {...} }];
201
+
* const validator = await LexiconValidator.create(lexicons);
202
+
* ```
203
+
*/
204
+
static async create(lexicons: LexiconDoc[]): Promise<LexiconValidator> {
205
+
await ensureWasmInit();
206
+
return new LexiconValidator(lexicons);
207
+
}
208
+
209
+
/**
210
+
* Validates a data record against its collection's lexicon schema.
211
+
*
212
+
* Performs comprehensive validation including:
213
+
* - Type checking
214
+
* - Constraint validation
215
+
* - Format validation
216
+
* - Required field checking
217
+
*
218
+
* @param collection - NSID of the collection (lexicon) to validate against
219
+
* @param record - Data record to validate
220
+
* @throws {ValidationError} If validation fails
221
+
*
222
+
* @example
223
+
* ```typescript
224
+
* validator.validateRecord("com.example.post", {
225
+
* text: "Hello world!",
226
+
* createdAt: "2024-01-01T12:00:00Z"
227
+
* });
228
+
* ```
229
+
*/
230
+
validateRecord(collection: string, record: Record<string, unknown>): void {
231
+
try {
232
+
const recordJson = JSON.stringify(record);
233
+
this.wasmValidator.validate_record(collection, recordJson);
234
+
} catch (error) {
235
+
throw new ValidationError(
236
+
error instanceof Error ? error.message : String(error)
237
+
);
238
+
}
239
+
}
240
+
241
+
/**
242
+
* Validates all lexicon documents and returns comprehensive error information.
243
+
*
244
+
* Uses the enhanced validation system that collects ALL errors for each lexicon,
245
+
* not just the first error encountered.
246
+
*
247
+
* @returns Null if validation passes, or error map if validation fails
248
+
*
249
+
* @example
250
+
* ```typescript
251
+
* const errors = validator.validateLexicons();
252
+
* if (errors) {
253
+
* console.log(`Found errors in ${Object.keys(errors).length} lexicons`);
254
+
* }
255
+
* ```
256
+
*/
257
+
validateLexicons(): Record<string, string[]> | null {
258
+
try {
259
+
const result = this.wasmValidator.validate_lexicons();
260
+
const errorMap = JSON.parse(result);
261
+
262
+
// Return null for success case (no errors)
263
+
if (Object.keys(errorMap).length === 0) {
264
+
return null;
265
+
}
266
+
267
+
return errorMap;
268
+
} catch (error) {
269
+
throw new ValidationError(
270
+
error instanceof Error ? error.message : String(error)
271
+
);
272
+
}
273
+
}
274
+
275
+
/**
276
+
* Checks for unresolved references across the lexicon set.
277
+
*
278
+
* Identifies references (like "$ref": "com.example.collection#definition")
279
+
* that point to non-existent lexicons or definitions.
280
+
*
281
+
* @returns Array of unresolved reference strings
282
+
*
283
+
* @example
284
+
* ```typescript
285
+
* const unresolved = validator.checkReferences();
286
+
* if (unresolved.length > 0) {
287
+
* console.log("Unresolved references:", unresolved);
288
+
* }
289
+
* ```
290
+
*/
291
+
checkReferences(): string[] {
292
+
try {
293
+
const result = this.wasmValidator.check_references();
294
+
return JSON.parse(result);
295
+
} catch (error) {
296
+
throw new ValidationError(
297
+
error instanceof Error ? error.message : String(error)
298
+
);
299
+
}
300
+
}
301
+
302
+
/**
303
+
* Retrieves detailed error context for debugging validation failures.
304
+
*
305
+
* Provides path information, current lexicon context, and circular
306
+
* reference detection state for enhanced debugging.
307
+
*
308
+
* @param path - Schema path to get context for
309
+
* @returns Detailed error context information
310
+
*
311
+
* @example
312
+
* ```typescript
313
+
* const context = validator.getErrorContext("com.example.post#main");
314
+
* console.log(`Validating at path: ${context.path}`);
315
+
* ```
316
+
*/
317
+
getErrorContext(path: string): ErrorContext {
318
+
try {
319
+
const result = this.wasmValidator.get_error_context(path);
320
+
return JSON.parse(result);
321
+
} catch (error) {
322
+
throw new ValidationError(
323
+
error instanceof Error ? error.message : String(error)
324
+
);
325
+
}
326
+
}
327
+
328
+
/**
329
+
* Manually releases WASM resources.
330
+
*
331
+
* Call this when done with the validator to free memory.
332
+
* Automatically called by dispose methods when using `using` syntax.
333
+
*/
334
+
free(): void {
335
+
this.wasmValidator.free();
336
+
}
337
+
338
+
/**
339
+
* Synchronous dispose method for automatic resource cleanup.
340
+
* Called automatically when using `using` keyword.
341
+
*
342
+
* @example
343
+
* ```typescript
344
+
* using validator = await LexiconValidator.create(lexicons);
345
+
* // Automatically cleaned up at end of scope
346
+
* ```
347
+
*/
348
+
[Symbol.dispose](): void {
349
+
this.free();
350
+
}
351
+
352
+
/**
353
+
* Asynchronous dispose method for automatic resource cleanup.
354
+
* Called automatically when using `await using` keyword.
355
+
*/
356
+
async [Symbol.asyncDispose](): Promise<void> {
357
+
await Promise.resolve(this.free());
358
+
}
359
+
}
360
+
361
+
// ============================================================================
362
+
// Standalone Validation Functions
363
+
// ============================================================================
364
+
365
+
/**
366
+
* Validates lexicon documents using the enhanced validation system.
367
+
*
368
+
* This is the primary validation function that collects ALL validation errors
369
+
* for each lexicon, enabling comprehensive error reporting.
370
+
*
371
+
* @param lexicons - Array of lexicon documents to validate
372
+
* @returns Null if validation succeeds, or error map if validation fails
373
+
*
374
+
* @example
375
+
* ```typescript
376
+
* const errors = await validate([
377
+
* { id: "com.example.post", defs: {...} },
378
+
* { id: "com.example.user", defs: {...} }
379
+
* ]);
380
+
*
381
+
* if (errors) {
382
+
* for (const [lexiconId, errorList] of Object.entries(errors)) {
383
+
* console.log(`${lexiconId}: ${errorList.length} errors`);
384
+
* }
385
+
* }
386
+
* ```
387
+
*/
388
+
export async function validate(
389
+
lexicons: LexiconDoc[]
390
+
): Promise<Record<string, string[]> | null> {
391
+
await ensureWasmInit();
392
+
393
+
const lexiconsJson = JSON.stringify(lexicons);
394
+
const result = validate_lexicons_and_get_errors(lexiconsJson);
395
+
const errorMap = JSON.parse(result);
396
+
397
+
// Success case: no errors found
398
+
if (Object.keys(errorMap).length === 0) {
399
+
return null;
400
+
}
401
+
402
+
// Return complete error map with all errors for each lexicon
403
+
return errorMap;
404
+
}
405
+
406
+
/**
407
+
* Enhanced validation function with comprehensive result statistics.
408
+
*
409
+
* Provides detailed validation results including error counts and statistics
410
+
* for better reporting and debugging.
411
+
*
412
+
* @param lexicons - Array of lexicon documents to validate
413
+
* @returns Detailed validation result with statistics
414
+
*
415
+
* @example
416
+
* ```typescript
417
+
* const result = await validateWithDetails(lexicons);
418
+
* console.log(`Validation ${result.valid ? 'passed' : 'failed'}`);
419
+
* console.log(`Total errors: ${result.totalErrors}`);
420
+
* console.log(`Lexicons with errors: ${result.lexiconsWithErrors}`);
421
+
* ```
422
+
*/
423
+
export async function validateWithDetails(
424
+
lexicons: LexiconDoc[]
425
+
): Promise<ValidationResult> {
426
+
const errors = await validate(lexicons);
427
+
428
+
if (errors === null) {
429
+
return {
430
+
valid: true,
431
+
errors: {},
432
+
totalErrors: 0,
433
+
lexiconsWithErrors: 0,
434
+
};
435
+
}
436
+
437
+
const totalErrors = Object.values(errors).reduce(
438
+
(sum, errorArray) => sum + errorArray.length,
439
+
0
440
+
);
441
+
442
+
return {
443
+
valid: false,
444
+
errors,
445
+
totalErrors,
446
+
lexiconsWithErrors: Object.keys(errors).length,
447
+
};
448
+
}
449
+
450
+
/**
451
+
* Validates a single data record against lexicon schemas.
452
+
*
453
+
* Convenience function that creates a temporary validator instance
454
+
* and automatically manages resources.
455
+
*
456
+
* @param lexicons - Array of lexicon documents containing the target schema
457
+
* @param collection - NSID of the collection to validate against
458
+
* @param record - Data record to validate
459
+
* @throws {ValidationError} If validation fails
460
+
*
461
+
* @example
462
+
* ```typescript
463
+
* await validateRecord(lexicons, "com.example.post", {
464
+
* text: "Hello world!",
465
+
* createdAt: "2024-01-01T12:00:00Z"
466
+
* });
467
+
* ```
468
+
*/
469
+
export async function validateRecord(
470
+
lexicons: LexiconDoc[],
471
+
collection: string,
472
+
record: Record<string, unknown>
473
+
): Promise<void> {
474
+
return await withValidator(lexicons, (validator) => {
475
+
validator.validateRecord(collection, record);
476
+
});
477
+
}
478
+
479
+
// ============================================================================
480
+
// Format and Utility Functions
481
+
// ============================================================================
482
+
483
+
/**
484
+
* Validates a string value against a specific AT Protocol format.
485
+
*
486
+
* Supports all AT Protocol string formats including:
487
+
* - datetime (RFC 3339)
488
+
* - uri, at-uri
489
+
* - did, handle
490
+
* - cid, tid
491
+
* - language (BCP 47)
492
+
*
493
+
* @param value - String value to validate
494
+
* @param format - AT Protocol format name
495
+
* @throws {ValidationError} If format validation fails
496
+
*
497
+
* @example
498
+
* ```typescript
499
+
* await validateStringFormat("2024-01-01T12:00:00Z", "datetime");
500
+
* await validateStringFormat("did:plc:example123", "did");
501
+
* ```
502
+
*/
503
+
export async function validateStringFormat(
504
+
value: string,
505
+
format: string
506
+
): Promise<void> {
507
+
await ensureWasmInit();
508
+
try {
509
+
validate_string_format(value, format);
510
+
} catch (error) {
511
+
throw new ValidationError(
512
+
error instanceof Error ? error.message : String(error)
513
+
);
514
+
}
515
+
}
516
+
517
+
/**
518
+
* Checks if a string is a valid NSID (Namespaced Identifier).
519
+
*
520
+
* NSIDs are used throughout AT Protocol to identify lexicons, collections,
521
+
* and procedures. They follow reverse-domain-name format with at least
522
+
* 3 segments (e.g., "com.example.collection").
523
+
*
524
+
* @param nsid - String to validate as NSID
525
+
* @returns True if valid NSID, false otherwise
526
+
*
527
+
* @example
528
+
* ```typescript
529
+
* console.log(await isValidNsid("com.example.post")); // true
530
+
* console.log(await isValidNsid("invalid-nsid")); // false
531
+
* ```
532
+
*/
533
+
export async function isValidNsid(nsid: string): Promise<boolean> {
534
+
await ensureWasmInit();
535
+
return is_valid_nsid(nsid);
536
+
}
537
+
538
+
// ============================================================================
539
+
// Resource Management Utilities
540
+
// ============================================================================
541
+
542
+
/**
543
+
* Utility function for automatic validator lifecycle management.
544
+
*
545
+
* Uses the callback pattern to ensure WASM resources are properly
546
+
* cleaned up, even if an exception occurs during validation.
547
+
*
548
+
* @param lexicons - Array of lexicon documents
549
+
* @param callback - Function to execute with the validator
550
+
* @returns Promise resolving to the callback's return value
551
+
*
552
+
* @example
553
+
* ```typescript
554
+
* const result = await withValidator(lexicons, (validator) => {
555
+
* validator.validateRecord("com.example.post", record);
556
+
* return "validation passed";
557
+
* });
558
+
* ```
559
+
*/
560
+
export async function withValidator<T>(
561
+
lexicons: LexiconDoc[],
562
+
callback: (validator: LexiconValidator) => T | Promise<T>
563
+
): Promise<T> {
564
+
const validator = await LexiconValidator.create(lexicons);
565
+
try {
566
+
return await callback(validator);
567
+
} finally {
568
+
validator.free();
569
+
}
570
+
}
-595
packages/lexicon-intellisense/src/slices_lexicon.js
-595
packages/lexicon-intellisense/src/slices_lexicon.js
···
1
-
// packages/lexicon/wasm/slices_lexicon.js
2
-
var wasm;
3
-
var cachedUint8ArrayMemory0 = null;
4
-
function getUint8ArrayMemory0() {
5
-
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
6
-
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
7
-
}
8
-
return cachedUint8ArrayMemory0;
9
-
}
10
-
var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", {
11
-
ignoreBOM: true,
12
-
fatal: true
13
-
}) : {
14
-
decode: () => {
15
-
throw Error("TextDecoder not available");
16
-
}
17
-
};
18
-
if (typeof TextDecoder !== "undefined") {
19
-
cachedTextDecoder.decode();
20
-
}
21
-
var MAX_SAFARI_DECODE_BYTES = 2146435072;
22
-
var numBytesDecoded = 0;
23
-
function decodeText(ptr, len) {
24
-
numBytesDecoded += len;
25
-
if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
26
-
cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", {
27
-
ignoreBOM: true,
28
-
fatal: true
29
-
}) : {
30
-
decode: () => {
31
-
throw Error("TextDecoder not available");
32
-
}
33
-
};
34
-
cachedTextDecoder.decode();
35
-
numBytesDecoded = len;
36
-
}
37
-
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
38
-
}
39
-
function getStringFromWasm0(ptr, len) {
40
-
ptr = ptr >>> 0;
41
-
return decodeText(ptr, len);
42
-
}
43
-
var WASM_VECTOR_LEN = 0;
44
-
var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : {
45
-
encode: () => {
46
-
throw Error("TextEncoder not available");
47
-
}
48
-
};
49
-
var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
50
-
return cachedTextEncoder.encodeInto(arg, view);
51
-
} : function(arg, view) {
52
-
const buf = cachedTextEncoder.encode(arg);
53
-
view.set(buf);
54
-
return {
55
-
read: arg.length,
56
-
written: buf.length
57
-
};
58
-
};
59
-
function passStringToWasm0(arg, malloc, realloc) {
60
-
if (realloc === void 0) {
61
-
const buf = cachedTextEncoder.encode(arg);
62
-
const ptr2 = malloc(buf.length, 1) >>> 0;
63
-
getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
64
-
WASM_VECTOR_LEN = buf.length;
65
-
return ptr2;
66
-
}
67
-
let len = arg.length;
68
-
let ptr = malloc(len, 1) >>> 0;
69
-
const mem = getUint8ArrayMemory0();
70
-
let offset = 0;
71
-
for (; offset < len; offset++) {
72
-
const code = arg.charCodeAt(offset);
73
-
if (code > 127) break;
74
-
mem[ptr + offset] = code;
75
-
}
76
-
if (offset !== len) {
77
-
if (offset !== 0) {
78
-
arg = arg.slice(offset);
79
-
}
80
-
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
81
-
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
82
-
const ret = encodeString(arg, view);
83
-
offset += ret.written;
84
-
ptr = realloc(ptr, len, offset, 1) >>> 0;
85
-
}
86
-
WASM_VECTOR_LEN = offset;
87
-
return ptr;
88
-
}
89
-
var cachedDataViewMemory0 = null;
90
-
function getDataViewMemory0() {
91
-
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
92
-
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
93
-
}
94
-
return cachedDataViewMemory0;
95
-
}
96
-
function takeFromExternrefTable0(idx) {
97
-
const value = wasm.__wbindgen_export_3.get(idx);
98
-
wasm.__externref_table_dealloc(idx);
99
-
return value;
100
-
}
101
-
function validate_lexicons_and_get_errors(lexicons_json) {
102
-
let deferred2_0;
103
-
let deferred2_1;
104
-
try {
105
-
const ptr0 = passStringToWasm0(lexicons_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
106
-
const len0 = WASM_VECTOR_LEN;
107
-
const ret = wasm.validate_lexicons_and_get_errors(ptr0, len0);
108
-
deferred2_0 = ret[0];
109
-
deferred2_1 = ret[1];
110
-
return getStringFromWasm0(ret[0], ret[1]);
111
-
} finally {
112
-
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
113
-
}
114
-
}
115
-
function validate_string_format(value, format) {
116
-
const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
117
-
const len0 = WASM_VECTOR_LEN;
118
-
const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
119
-
const len1 = WASM_VECTOR_LEN;
120
-
const ret = wasm.validate_string_format(ptr0, len0, ptr1, len1);
121
-
if (ret[1]) {
122
-
throw takeFromExternrefTable0(ret[0]);
123
-
}
124
-
}
125
-
function is_valid_nsid(nsid) {
126
-
const ptr0 = passStringToWasm0(nsid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
127
-
const len0 = WASM_VECTOR_LEN;
128
-
const ret = wasm.is_valid_nsid(ptr0, len0);
129
-
return ret !== 0;
130
-
}
131
-
var WasmLexiconValidatorFinalization = typeof FinalizationRegistry === "undefined" ? {
132
-
register: () => {
133
-
},
134
-
unregister: () => {
135
-
}
136
-
} : new FinalizationRegistry((ptr) => wasm.__wbg_wasmlexiconvalidator_free(ptr >>> 0, 1));
137
-
var WasmLexiconValidator = class {
138
-
__destroy_into_raw() {
139
-
const ptr = this.__wbg_ptr;
140
-
this.__wbg_ptr = 0;
141
-
WasmLexiconValidatorFinalization.unregister(this);
142
-
return ptr;
143
-
}
144
-
free() {
145
-
const ptr = this.__destroy_into_raw();
146
-
wasm.__wbg_wasmlexiconvalidator_free(ptr, 0);
147
-
}
148
-
/**
149
-
* Create a new validator with the given lexicon documents
150
-
* Takes a JSON string containing an array of lexicon documents
151
-
* @param {string} lexicons_json
152
-
*/
153
-
constructor(lexicons_json) {
154
-
const ptr0 = passStringToWasm0(lexicons_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
155
-
const len0 = WASM_VECTOR_LEN;
156
-
const ret = wasm.wasmlexiconvalidator_new(ptr0, len0);
157
-
if (ret[2]) {
158
-
throw takeFromExternrefTable0(ret[1]);
159
-
}
160
-
this.__wbg_ptr = ret[0] >>> 0;
161
-
WasmLexiconValidatorFinalization.register(this, this.__wbg_ptr, this);
162
-
return this;
163
-
}
164
-
/**
165
-
* Validate a record against its collection's lexicon
166
-
* Takes collection name and record as JSON strings
167
-
* @param {string} collection
168
-
* @param {string} record_json
169
-
*/
170
-
validate_record(collection, record_json) {
171
-
const ptr0 = passStringToWasm0(collection, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
172
-
const len0 = WASM_VECTOR_LEN;
173
-
const ptr1 = passStringToWasm0(record_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
174
-
const len1 = WASM_VECTOR_LEN;
175
-
const ret = wasm.wasmlexiconvalidator_validate_record(this.__wbg_ptr, ptr0, len0, ptr1, len1);
176
-
if (ret[1]) {
177
-
throw takeFromExternrefTable0(ret[0]);
178
-
}
179
-
}
180
-
/**
181
-
* Validate lexicon documents and return detailed validation results
182
-
* Returns a JSON string containing validation results with enhanced error context
183
-
* @returns {string}
184
-
*/
185
-
validate_lexicons() {
186
-
let deferred1_0;
187
-
let deferred1_1;
188
-
try {
189
-
const ret = wasm.wasmlexiconvalidator_validate_lexicons(this.__wbg_ptr);
190
-
deferred1_0 = ret[0];
191
-
deferred1_1 = ret[1];
192
-
return getStringFromWasm0(ret[0], ret[1]);
193
-
} finally {
194
-
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
195
-
}
196
-
}
197
-
/**
198
-
* Check if all references in the lexicon set can be resolved
199
-
* Returns a JSON string with any unresolved references
200
-
* @returns {string}
201
-
*/
202
-
check_references() {
203
-
let deferred1_0;
204
-
let deferred1_1;
205
-
try {
206
-
const ret = wasm.wasmlexiconvalidator_check_references(this.__wbg_ptr);
207
-
deferred1_0 = ret[0];
208
-
deferred1_1 = ret[1];
209
-
return getStringFromWasm0(ret[0], ret[1]);
210
-
} finally {
211
-
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
212
-
}
213
-
}
214
-
/**
215
-
* Get detailed error context for validation failures
216
-
* Returns enhanced error information with path context
217
-
* @param {string} path
218
-
* @returns {string}
219
-
*/
220
-
get_error_context(path) {
221
-
let deferred2_0;
222
-
let deferred2_1;
223
-
try {
224
-
const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
225
-
const len0 = WASM_VECTOR_LEN;
226
-
const ret = wasm.wasmlexiconvalidator_get_error_context(this.__wbg_ptr, ptr0, len0);
227
-
deferred2_0 = ret[0];
228
-
deferred2_1 = ret[1];
229
-
return getStringFromWasm0(ret[0], ret[1]);
230
-
} finally {
231
-
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
232
-
}
233
-
}
234
-
};
235
-
var EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set([
236
-
"basic",
237
-
"cors",
238
-
"default"
239
-
]);
240
-
async function __wbg_load(module, imports) {
241
-
if (typeof Response === "function" && module instanceof Response) {
242
-
if (typeof WebAssembly.instantiateStreaming === "function") {
243
-
try {
244
-
return await WebAssembly.instantiateStreaming(module, imports);
245
-
} catch (e) {
246
-
const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
247
-
if (validResponse && module.headers.get("Content-Type") !== "application/wasm") {
248
-
console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
249
-
} else {
250
-
throw e;
251
-
}
252
-
}
253
-
}
254
-
const bytes = await module.arrayBuffer();
255
-
return await WebAssembly.instantiate(bytes, imports);
256
-
} else {
257
-
const instance = await WebAssembly.instantiate(module, imports);
258
-
if (instance instanceof WebAssembly.Instance) {
259
-
return {
260
-
instance,
261
-
module
262
-
};
263
-
} else {
264
-
return instance;
265
-
}
266
-
}
267
-
}
268
-
function __wbg_get_imports() {
269
-
const imports = {};
270
-
imports.wbg = {};
271
-
imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
272
-
let deferred0_0;
273
-
let deferred0_1;
274
-
try {
275
-
deferred0_0 = arg0;
276
-
deferred0_1 = arg1;
277
-
console.error(getStringFromWasm0(arg0, arg1));
278
-
} finally {
279
-
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
280
-
}
281
-
};
282
-
imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
283
-
const ret = new Error();
284
-
return ret;
285
-
};
286
-
imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
287
-
const ret = arg1.stack;
288
-
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
289
-
const len1 = WASM_VECTOR_LEN;
290
-
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
291
-
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
292
-
};
293
-
imports.wbg.__wbg_wbindgenthrow_4c11a24fca429ccf = function(arg0, arg1) {
294
-
throw new Error(getStringFromWasm0(arg0, arg1));
295
-
};
296
-
imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
297
-
const ret = getStringFromWasm0(arg0, arg1);
298
-
return ret;
299
-
};
300
-
imports.wbg.__wbindgen_init_externref_table = function() {
301
-
const table = wasm.__wbindgen_export_3;
302
-
const offset = table.grow(4);
303
-
table.set(0, void 0);
304
-
table.set(offset + 0, void 0);
305
-
table.set(offset + 1, null);
306
-
table.set(offset + 2, true);
307
-
table.set(offset + 3, false);
308
-
;
309
-
};
310
-
return imports;
311
-
}
312
-
function __wbg_init_memory(imports, memory) {
313
-
}
314
-
function __wbg_finalize_init(instance, module) {
315
-
wasm = instance.exports;
316
-
__wbg_init.__wbindgen_wasm_module = module;
317
-
cachedDataViewMemory0 = null;
318
-
cachedUint8ArrayMemory0 = null;
319
-
wasm.__wbindgen_start();
320
-
return wasm;
321
-
}
322
-
async function __wbg_init(module_or_path) {
323
-
if (wasm !== void 0) return wasm;
324
-
if (typeof module_or_path !== "undefined") {
325
-
if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
326
-
({ module_or_path } = module_or_path);
327
-
} else {
328
-
console.warn("using deprecated parameters for the initialization function; pass a single object instead");
329
-
}
330
-
}
331
-
if (typeof module_or_path === "undefined") {
332
-
module_or_path = new URL("slices_lexicon_bg.wasm", import.meta.url);
333
-
}
334
-
const imports = __wbg_get_imports();
335
-
if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
336
-
module_or_path = fetch(module_or_path);
337
-
}
338
-
__wbg_init_memory(imports);
339
-
const { instance, module } = await __wbg_load(await module_or_path, imports);
340
-
return __wbg_finalize_init(instance, module);
341
-
}
342
-
var slices_lexicon_default = __wbg_init;
343
-
344
-
// packages/lexicon/lexicon.ts
345
-
var _computedKey;
346
-
var _computedKey1;
347
-
var wasmInitialized = false;
348
-
async function ensureWasmInit() {
349
-
if (!wasmInitialized) {
350
-
const wasmUrl = new URL("./wasm/slices_lexicon_bg.wasm", import.meta.url);
351
-
await slices_lexicon_default({
352
-
module_or_path: wasmUrl
353
-
});
354
-
wasmInitialized = true;
355
-
}
356
-
}
357
-
var ValidationError = class extends Error {
358
-
/**
359
-
* Creates a new ValidationError instance.
360
-
*
361
-
* @param message - Human-readable error description
362
-
*/
363
-
constructor(message) {
364
-
super(message);
365
-
this.name = "ValidationError";
366
-
}
367
-
};
368
-
_computedKey = Symbol.dispose, _computedKey1 = Symbol.asyncDispose;
369
-
var LexiconValidator = class _LexiconValidator {
370
-
wasmValidator;
371
-
/**
372
-
* Creates a new validator instance with the provided lexicon documents.
373
-
*
374
-
* Note: Prefer using the static `create()` method for async initialization.
375
-
*
376
-
* @param lexicons - Array of lexicon documents to validate
377
-
*/
378
-
constructor(lexicons) {
379
-
const lexiconsJson = JSON.stringify(lexicons);
380
-
this.wasmValidator = new WasmLexiconValidator(lexiconsJson);
381
-
}
382
-
/**
383
-
* Creates a new validator instance with proper async initialization.
384
-
* Ensures WASM module is loaded before creating the validator.
385
-
*
386
-
* @param lexicons - Array of lexicon documents to validate
387
-
* @returns Promise resolving to a new validator instance
388
-
*
389
-
* @example
390
-
* ```typescript
391
-
* const lexicons = [{ id: "com.example.post", defs: {...} }];
392
-
* const validator = await LexiconValidator.create(lexicons);
393
-
* ```
394
-
*/
395
-
static async create(lexicons) {
396
-
await ensureWasmInit();
397
-
return new _LexiconValidator(lexicons);
398
-
}
399
-
/**
400
-
* Validates a data record against its collection's lexicon schema.
401
-
*
402
-
* Performs comprehensive validation including:
403
-
* - Type checking
404
-
* - Constraint validation
405
-
* - Format validation
406
-
* - Required field checking
407
-
*
408
-
* @param collection - NSID of the collection (lexicon) to validate against
409
-
* @param record - Data record to validate
410
-
* @throws {ValidationError} If validation fails
411
-
*
412
-
* @example
413
-
* ```typescript
414
-
* validator.validateRecord("com.example.post", {
415
-
* text: "Hello world!",
416
-
* createdAt: "2024-01-01T12:00:00Z"
417
-
* });
418
-
* ```
419
-
*/
420
-
validateRecord(collection, record) {
421
-
try {
422
-
const recordJson = JSON.stringify(record);
423
-
this.wasmValidator.validate_record(collection, recordJson);
424
-
} catch (error) {
425
-
throw new ValidationError(error instanceof Error ? error.message : String(error));
426
-
}
427
-
}
428
-
/**
429
-
* Validates all lexicon documents and returns comprehensive error information.
430
-
*
431
-
* Uses the enhanced validation system that collects ALL errors for each lexicon,
432
-
* not just the first error encountered.
433
-
*
434
-
* @returns Null if validation passes, or error map if validation fails
435
-
*
436
-
* @example
437
-
* ```typescript
438
-
* const errors = validator.validateLexicons();
439
-
* if (errors) {
440
-
* console.log(`Found errors in ${Object.keys(errors).length} lexicons`);
441
-
* }
442
-
* ```
443
-
*/
444
-
validateLexicons() {
445
-
try {
446
-
const result = this.wasmValidator.validate_lexicons();
447
-
const errorMap = JSON.parse(result);
448
-
if (Object.keys(errorMap).length === 0) {
449
-
return null;
450
-
}
451
-
return errorMap;
452
-
} catch (error) {
453
-
throw new ValidationError(error instanceof Error ? error.message : String(error));
454
-
}
455
-
}
456
-
/**
457
-
* Checks for unresolved references across the lexicon set.
458
-
*
459
-
* Identifies references (like "$ref": "com.example.collection#definition")
460
-
* that point to non-existent lexicons or definitions.
461
-
*
462
-
* @returns Array of unresolved reference strings
463
-
*
464
-
* @example
465
-
* ```typescript
466
-
* const unresolved = validator.checkReferences();
467
-
* if (unresolved.length > 0) {
468
-
* console.log("Unresolved references:", unresolved);
469
-
* }
470
-
* ```
471
-
*/
472
-
checkReferences() {
473
-
try {
474
-
const result = this.wasmValidator.check_references();
475
-
return JSON.parse(result);
476
-
} catch (error) {
477
-
throw new ValidationError(error instanceof Error ? error.message : String(error));
478
-
}
479
-
}
480
-
/**
481
-
* Retrieves detailed error context for debugging validation failures.
482
-
*
483
-
* Provides path information, current lexicon context, and circular
484
-
* reference detection state for enhanced debugging.
485
-
*
486
-
* @param path - Schema path to get context for
487
-
* @returns Detailed error context information
488
-
*
489
-
* @example
490
-
* ```typescript
491
-
* const context = validator.getErrorContext("com.example.post#main");
492
-
* console.log(`Validating at path: ${context.path}`);
493
-
* ```
494
-
*/
495
-
getErrorContext(path) {
496
-
try {
497
-
const result = this.wasmValidator.get_error_context(path);
498
-
return JSON.parse(result);
499
-
} catch (error) {
500
-
throw new ValidationError(error instanceof Error ? error.message : String(error));
501
-
}
502
-
}
503
-
/**
504
-
* Manually releases WASM resources.
505
-
*
506
-
* Call this when done with the validator to free memory.
507
-
* Automatically called by dispose methods when using `using` syntax.
508
-
*/
509
-
free() {
510
-
this.wasmValidator.free();
511
-
}
512
-
/**
513
-
* Synchronous dispose method for automatic resource cleanup.
514
-
* Called automatically when using `using` keyword.
515
-
*
516
-
* @example
517
-
* ```typescript
518
-
* using validator = await LexiconValidator.create(lexicons);
519
-
* // Automatically cleaned up at end of scope
520
-
* ```
521
-
*/
522
-
[_computedKey]() {
523
-
this.free();
524
-
}
525
-
/**
526
-
* Asynchronous dispose method for automatic resource cleanup.
527
-
* Called automatically when using `await using` keyword.
528
-
*/
529
-
async [_computedKey1]() {
530
-
await Promise.resolve(this.free());
531
-
}
532
-
};
533
-
async function validate(lexicons) {
534
-
await ensureWasmInit();
535
-
const lexiconsJson = JSON.stringify(lexicons);
536
-
const result = validate_lexicons_and_get_errors(lexiconsJson);
537
-
const errorMap = JSON.parse(result);
538
-
if (Object.keys(errorMap).length === 0) {
539
-
return null;
540
-
}
541
-
return errorMap;
542
-
}
543
-
async function validateWithDetails(lexicons) {
544
-
const errors = await validate(lexicons);
545
-
if (errors === null) {
546
-
return {
547
-
valid: true,
548
-
errors: {},
549
-
totalErrors: 0,
550
-
lexiconsWithErrors: 0
551
-
};
552
-
}
553
-
const totalErrors = Object.values(errors).reduce((sum, errorArray) => sum + errorArray.length, 0);
554
-
return {
555
-
valid: false,
556
-
errors,
557
-
totalErrors,
558
-
lexiconsWithErrors: Object.keys(errors).length
559
-
};
560
-
}
561
-
async function validateRecord(lexicons, collection, record) {
562
-
return await withValidator(lexicons, (validator) => {
563
-
validator.validateRecord(collection, record);
564
-
});
565
-
}
566
-
async function validateStringFormat(value, format) {
567
-
await ensureWasmInit();
568
-
try {
569
-
validate_string_format(value, format);
570
-
} catch (error) {
571
-
throw new ValidationError(error instanceof Error ? error.message : String(error));
572
-
}
573
-
}
574
-
async function isValidNsid(nsid) {
575
-
await ensureWasmInit();
576
-
return is_valid_nsid(nsid);
577
-
}
578
-
async function withValidator(lexicons, callback) {
579
-
const validator = await LexiconValidator.create(lexicons);
580
-
try {
581
-
return await callback(validator);
582
-
} finally {
583
-
validator.free();
584
-
}
585
-
}
586
-
export {
587
-
LexiconValidator,
588
-
ValidationError,
589
-
isValidNsid,
590
-
validate,
591
-
validateRecord,
592
-
validateStringFormat,
593
-
validateWithDetails,
594
-
withValidator
595
-
};
packages/lexicon-intellisense/wasm/slices_lexicon_bg.wasm
packages/lexicon-intellisense/wasm/slices_lexicon_bg.wasm
This is a binary file and will not be displayed.