+6

.changeset/thin-papayas-study.md

··· 1 1 + --- 2 2 + '@atcute/bluemoji': patch 3 3 + '@atcute/lexicon-doc': patch 4 4 + --- 5 5 + 6 6 + validate default/const/known values with the given constraints

+1 -1

lexdocs/bluemoji/blue.moji/collection/item.json

··· 29 29 "refs": ["com.atproto.label.defs#selfLabels"] 30 30 }, 31 31 "copyOf": { "type": "string", "format": "at-uri" }, 32 32 - "fallbackText": { "type": "string", "maxLength": 1, "default": "◌" } 32 32 + "fallbackText": { "type": "string", "maxLength": 10, "maxGraphemes": 1, "default": "◌" } 33 33 } 34 34 } 35 35 },

+4 -1

packages/definitions/bluemoji/lib/lexicons/types/blue/moji/collection/item.ts

··· 45 45 copyOf: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.resourceUriString()), 46 46 createdAt: /*#__PURE__*/ v.datetimeString(), 47 47 fallbackText: /*#__PURE__*/ v.optional( 48 48 - /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 1)]), 48 48 + /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [ 49 49 + /*#__PURE__*/ v.stringLength(0, 10), 50 50 + /*#__PURE__*/ v.stringGraphemes(0, 1), 51 51 + ]), 49 52 '◌', 50 53 ), 51 54 get formats() {

+343 -38

packages/lexicons/lexicon-doc/lib/schema.ts

··· 1 1 import * as v from '@badrap/valita'; 2 2 3 3 + import { isWithinGraphemeBounds, isWithinUtf8Bounds } from './utils.js'; 4 4 + 3 5 // tsc dislikes this schema with the amount of type expansion that happens here. 4 6 // the interface declaration allows tsc to just reference it instead of 5 7 // expanding on every type reference. ··· 32 34 export interface $schema extends $schematype {} 33 35 } 34 36 35 35 - const _lexInteger = v.object({ 36 36 - type: v.literal('integer'), 37 37 - description: v.string().optional(), 38 38 - default: integer.optional(), 39 39 - minimum: integer.optional(), 40 40 - maximum: integer.optional(), 41 41 - enum: v.array(integer).optional(), 42 42 - const: integer.optional(), 43 43 - }); 37 37 + const _lexInteger = v 38 38 + .object({ 39 39 + type: v.literal('integer'), 40 40 + description: v.string().optional(), 41 41 + default: integer.optional(), 42 42 + minimum: integer.optional(), 43 43 + maximum: integer.optional(), 44 44 + enum: v.array(integer).optional(), 45 45 + const: integer.optional(), 46 46 + }) 47 47 + .chain((input) => { 48 48 + const { 49 49 + minimum = 0, 50 50 + maximum = Infinity, 51 51 + const: constValue, 52 52 + default: defaultValue, 53 53 + enum: enumValues, 54 54 + } = input; 55 55 + 56 56 + if (minimum > maximum) { 57 57 + return v.err({ 58 58 + message: `minimum value can't be greater than maximum value`, 59 59 + path: ['minimum'], 60 60 + }); 61 61 + } 62 62 + 63 63 + if (defaultValue !== undefined) { 64 64 + if (defaultValue < minimum) { 65 65 + return v.err({ 66 66 + message: `default value can't be lower than minimum value`, 67 67 + path: ['default'], 68 68 + }); 69 69 + } 70 70 + 71 71 + if (defaultValue > maximum) { 72 72 + return v.err({ 73 73 + message: `default value can't be greater than maximum value`, 74 74 + path: ['default'], 75 75 + }); 76 76 + } 77 77 + } 78 78 + 79 79 + if (constValue !== undefined) { 80 80 + if (constValue < minimum) { 81 81 + return v.err({ 82 82 + message: `const value can't be lower than minimum value`, 83 83 + path: ['const'], 84 84 + }); 85 85 + } 86 86 + 87 87 + if (constValue > maximum) { 88 88 + return v.err({ 89 89 + message: `const value can't be greater than maximum value`, 90 90 + path: ['const'], 91 91 + }); 92 92 + } 93 93 + } 94 94 + 95 95 + if (enumValues !== undefined) { 96 96 + for (let idx = 0, len = enumValues.length; idx < len; idx++) { 97 97 + const enumValue = enumValues[idx]; 98 98 + 99 99 + if (enumValue < minimum) { 100 100 + return v.err({ 101 101 + message: `enum value can't be lower than minimum value`, 102 102 + path: ['enum', idx], 103 103 + }); 104 104 + } 105 105 + 106 106 + if (enumValue > maximum) { 107 107 + return v.err({ 108 108 + message: `enum value can't be greater than maximum value`, 109 109 + path: ['enum', idx], 110 110 + }); 111 111 + } 112 112 + } 113 113 + } 114 114 + 115 115 + return v.ok(input); 116 116 + }); 44 117 45 118 export const lexInteger = _lexInteger as lexInteger.$schema; 46 119 export interface LexInteger extends v.Infer<typeof lexInteger> {} ··· 74 147 export interface $schema extends $schematype {} 75 148 } 76 149 77 77 - const _lexString = v.object({ 78 78 - type: v.literal('string'), 79 79 - format: lexStringFormat.optional(), 80 80 - description: v.string().optional(), 81 81 - default: v.string().optional(), 82 82 - minLength: integer.optional(), 83 83 - maxLength: integer.optional(), 84 84 - minGraphemes: integer.optional(), 85 85 - maxGraphemes: integer.optional(), 86 86 - enum: v.array(v.string()).optional(), 87 87 - const: v.string().optional(), 88 88 - knownValues: v.array(v.string()).optional(), 89 89 - }); 150 150 + const _lexString = v 151 151 + .object({ 152 152 + type: v.literal('string'), 153 153 + format: lexStringFormat.optional(), 154 154 + description: v.string().optional(), 155 155 + default: v.string().optional(), 156 156 + minLength: integer.optional(), 157 157 + maxLength: integer.optional(), 158 158 + minGraphemes: integer.optional(), 159 159 + maxGraphemes: integer.optional(), 160 160 + enum: v.array(v.string()).optional(), 161 161 + const: v.string().optional(), 162 162 + knownValues: v.array(v.string()).optional(), 163 163 + }) 164 164 + .chain((input) => { 165 165 + const { 166 166 + minLength = 0, 167 167 + maxLength = Infinity, 168 168 + minGraphemes = 0, 169 169 + maxGraphemes = Infinity, 170 170 + const: constValue, 171 171 + default: defaultValue, 172 172 + enum: enumValues, 173 173 + knownValues, 174 174 + } = input; 175 175 + 176 176 + if (minLength > maxLength) { 177 177 + return v.err({ 178 178 + message: `minimum string length can't be greater than maximum string length`, 179 179 + path: ['minLength'], 180 180 + }); 181 181 + } 182 182 + 183 183 + if (minGraphemes > maxGraphemes) { 184 184 + return v.err({ 185 185 + message: `minimum grapheme count can't be greater than maximum grapheme count`, 186 186 + path: ['minGraphemes'], 187 187 + }); 188 188 + } 189 189 + 190 190 + if (defaultValue !== undefined) { 191 191 + { 192 192 + const bound = isWithinUtf8Bounds(defaultValue, minLength, maxLength); 193 193 + 194 194 + if (bound === 'min') { 195 195 + return v.err({ 196 196 + message: `default value can't be shorter than minimum string length`, 197 197 + path: ['default'], 198 198 + }); 199 199 + } 200 200 + 201 201 + if (bound === 'max') { 202 202 + return v.err({ 203 203 + message: `default value can't be longer than maximum string length`, 204 204 + path: ['default'], 205 205 + }); 206 206 + } 207 207 + } 208 208 + 209 209 + { 210 210 + const bound = isWithinGraphemeBounds(defaultValue, minLength, maxLength); 211 211 + 212 212 + if (bound === 'min') { 213 213 + return v.err({ 214 214 + message: `default value can't be shorter than minimum grapheme count`, 215 215 + path: ['default'], 216 216 + }); 217 217 + } 218 218 + 219 219 + if (bound === 'max') { 220 220 + return v.err({ 221 221 + message: `default value can't be longer than minimum grapheme count`, 222 222 + path: ['default'], 223 223 + }); 224 224 + } 225 225 + } 226 226 + } 227 227 + 228 228 + if (constValue !== undefined) { 229 229 + { 230 230 + const bound = isWithinUtf8Bounds(constValue, minLength, maxLength); 231 231 + 232 232 + if (bound === 'min') { 233 233 + return v.err({ 234 234 + message: `const value can't be shorter than minimum string length`, 235 235 + path: ['const'], 236 236 + }); 237 237 + } 238 238 + 239 239 + if (bound === 'max') { 240 240 + return v.err({ 241 241 + message: `const value can't be longer than maximum string length`, 242 242 + path: ['const'], 243 243 + }); 244 244 + } 245 245 + } 246 246 + 247 247 + { 248 248 + const bound = isWithinGraphemeBounds(constValue, minLength, maxLength); 249 249 + 250 250 + if (bound === 'min') { 251 251 + return v.err({ 252 252 + message: `const value can't be shorter than minimum grapheme count`, 253 253 + path: ['const'], 254 254 + }); 255 255 + } 256 256 + 257 257 + if (bound === 'max') { 258 258 + return v.err({ 259 259 + message: `const value can't be longer than minimum grapheme count`, 260 260 + path: ['const'], 261 261 + }); 262 262 + } 263 263 + } 264 264 + } 265 265 + 266 266 + if (enumValues !== undefined) { 267 267 + for (let idx = 0, len = enumValues.length; idx < len; idx++) { 268 268 + const enumValue = enumValues[idx]; 269 269 + 270 270 + { 271 271 + const bound = isWithinUtf8Bounds(enumValue, minLength, maxLength); 272 272 + 273 273 + if (bound === 'min') { 274 274 + return v.err({ 275 275 + message: `enum value can't be shorter than minimum string length`, 276 276 + path: ['enum', idx], 277 277 + }); 278 278 + } 279 279 + 280 280 + if (bound === 'max') { 281 281 + return v.err({ 282 282 + message: `enum value can't be longer than maximum string length`, 283 283 + path: ['enum', idx], 284 284 + }); 285 285 + } 286 286 + } 287 287 + 288 288 + { 289 289 + const bound = isWithinGraphemeBounds(enumValue, minGraphemes, maxGraphemes); 290 290 + 291 291 + if (bound === 'min') { 292 292 + return v.err({ 293 293 + message: `enum value can't have fewer graphemes than minimum grapheme count`, 294 294 + path: ['enum', idx], 295 295 + }); 296 296 + } 297 297 + 298 298 + if (bound === 'max') { 299 299 + return v.err({ 300 300 + message: `enum value can't have more graphemes than maximum grapheme count`, 301 301 + path: ['enum', idx], 302 302 + }); 303 303 + } 304 304 + } 305 305 + } 306 306 + } 307 307 + 308 308 + if (knownValues !== undefined) { 309 309 + for (let idx = 0, len = knownValues.length; idx < len; idx++) { 310 310 + const knownValue = knownValues[idx]; 311 311 + 312 312 + { 313 313 + const bound = isWithinUtf8Bounds(knownValue, minLength, maxLength); 314 314 + 315 315 + if (bound === 'min') { 316 316 + return v.err({ 317 317 + message: `known value can't be shorter than minimum string length`, 318 318 + path: ['known', idx], 319 319 + }); 320 320 + } 321 321 + 322 322 + if (bound === 'max') { 323 323 + return v.err({ 324 324 + message: `known value can't be longer than maximum string length`, 325 325 + path: ['known', idx], 326 326 + }); 327 327 + } 328 328 + } 329 329 + 330 330 + { 331 331 + const bound = isWithinGraphemeBounds(knownValue, minGraphemes, maxGraphemes); 332 332 + 333 333 + if (bound === 'min') { 334 334 + return v.err({ 335 335 + message: `known value can't have fewer graphemes than minimum grapheme count`, 336 336 + path: ['known', idx], 337 337 + }); 338 338 + } 339 339 + 340 340 + if (bound === 'max') { 341 341 + return v.err({ 342 342 + message: `known value can't have more graphemes than maximum grapheme count`, 343 343 + path: ['known', idx], 344 344 + }); 345 345 + } 346 346 + } 347 347 + } 348 348 + } 349 349 + 350 350 + return v.ok(input); 351 351 + }); 90 352 91 353 export const lexString = _lexString as lexString.$schema; 92 354 export interface LexString extends v.Infer<typeof lexString> {} ··· 122 384 export interface $schema extends $schematype {} 123 385 } 124 386 125 125 - const _lexBytes = v.object({ 126 126 - type: v.literal('bytes'), 127 127 - description: v.string().optional(), 128 128 - minLength: integer.optional(), 129 129 - maxLength: integer.optional(), 130 130 - }); 387 387 + const _lexBytes = v 388 388 + .object({ 389 389 + type: v.literal('bytes'), 390 390 + description: v.string().optional(), 391 391 + minLength: integer.optional(), 392 392 + maxLength: integer.optional(), 393 393 + }) 394 394 + .chain((input) => { 395 395 + const { minLength = 0, maxLength = Infinity } = input; 396 396 + 397 397 + if (minLength > maxLength) { 398 398 + return v.err({ 399 399 + message: `minimum byte length can't be greater than maximum byte length`, 400 400 + path: ['minLength'], 401 401 + }); 402 402 + } 403 403 + 404 404 + return v.ok(input); 405 405 + }); 131 406 132 407 export const lexBytes = _lexBytes as lexBytes.$schema; 133 408 export interface LexBytes extends v.Infer<typeof lexBytes> {} ··· 226 501 export interface $schema extends $schematype {} 227 502 } 228 503 229 229 - const _lexArray = v.object({ 230 230 - type: v.literal('array'), 231 231 - description: v.string().optional(), 232 232 - items: v.union(lexPrimitive, lexIpldType, lexRefVariant, lexBlob), 233 233 - minLength: integer.optional(), 234 234 - maxLength: integer.optional(), 235 235 - }); 504 504 + const _lexArray = v 505 505 + .object({ 506 506 + type: v.literal('array'), 507 507 + description: v.string().optional(), 508 508 + items: v.union(lexPrimitive, lexIpldType, lexRefVariant, lexBlob), 509 509 + minLength: integer.optional(), 510 510 + maxLength: integer.optional(), 511 511 + }) 512 512 + .chain((input) => { 513 513 + const { minLength = 0, maxLength = Infinity } = input; 514 514 + 515 515 + if (minLength > maxLength) { 516 516 + return v.err({ 517 517 + message: `minimum array length can't be greater than maximum array length`, 518 518 + path: ['minLength'], 519 519 + }); 520 520 + } 521 521 + 522 522 + return v.ok(input); 523 523 + }); 236 524 237 525 export const lexArray = _lexArray as lexArray.$schema; 238 526 export interface LexArray extends v.Infer<typeof lexArray> {} ··· 243 531 export interface $schema extends $schematype {} 244 532 } 245 533 246 246 - const _lexPrimitiveArray = lexArray.extend({ 247 247 - items: lexPrimitive, 248 248 - }); 534 534 + const _lexPrimitiveArray = v 535 535 + .object({ 536 536 + type: v.literal('array'), 537 537 + description: v.string().optional(), 538 538 + items: lexPrimitive, 539 539 + minLength: integer.optional(), 540 540 + maxLength: integer.optional(), 541 541 + }) 542 542 + .chain((input) => { 543 543 + const { minLength = 0, maxLength = Infinity } = input; 544 544 + 545 545 + if (minLength > maxLength) { 546 546 + return v.err({ 547 547 + message: `minimum array length can't be greater than maximum array length`, 548 548 + path: ['minLength'], 549 549 + }); 550 550 + } 551 551 + 552 552 + return v.ok(input); 553 553 + }); 249 554 250 555 export const lexPrimitiveArray = _lexPrimitiveArray as lexPrimitiveArray.$schema; 251 556 export interface LexPrimitiveArray extends v.Infer<typeof lexPrimitiveArray> {}

+126

packages/lexicons/lexicon-doc/lib/utils.ts

··· 1 1 + const segmenter = new Intl.Segmenter(); 2 2 + 3 3 + export const isWithinUtf8Bounds = (input: string, min = 0, max = Infinity): 'max' | 'min' | undefined => { 4 4 + const maybeUtf8Len = input.length * 3; 5 5 + 6 6 + // fail early if we're still less than minimum length 7 7 + if (maybeUtf8Len < min) { 8 8 + return 'min'; 9 9 + } 10 10 + 11 11 + // skip if we're still within maximum length 12 12 + if (maybeUtf8Len <= max) { 13 13 + return undefined; 14 14 + } 15 15 + 16 16 + const utf8Len = getUtf8Length(input); 17 17 + 18 18 + if (utf8Len < min) { 19 19 + return 'min'; 20 20 + } 21 21 + 22 22 + if (utf8Len > max) { 23 23 + return 'max'; 24 24 + } 25 25 + 26 26 + return undefined; 27 27 + }; 28 28 + 29 29 + export const isWithinGraphemeBounds = (input: string, min = 0, max = Infinity): 'max' | 'min' | undefined => { 30 30 + // grapheme conversion is expensive, so we're going to do some safe naive 31 31 + // checks where we assume 1 UTF-16 character = 1 grapheme. 32 32 + 33 33 + const utf16Len = input.length; 34 34 + 35 35 + // fail early if UTF-16 length is less than grapheme length 36 36 + if (utf16Len < min) { 37 37 + return 'min'; 38 38 + } 39 39 + 40 40 + // skip if we're still within maximum constraint 41 41 + if (utf16Len <= max) { 42 42 + return undefined; 43 43 + } 44 44 + 45 45 + const graphemeLen = getGraphemeLength(input); 46 46 + 47 47 + if (graphemeLen < min) { 48 48 + return 'min'; 49 49 + } 50 50 + 51 51 + if (graphemeLen > max) { 52 52 + return 'max'; 53 53 + } 54 54 + 55 55 + return undefined; 56 56 + }; 57 57 + 58 58 + export const getUtf8Length = (str: string): number => { 59 59 + const len = str.length; 60 60 + 61 61 + let u16pos = 0; 62 62 + let u8pos = 0; 63 63 + 64 64 + jump: if (str.charCodeAt(0) < 0x80) { 65 65 + u16pos++; 66 66 + u8pos++; 67 67 + 68 68 + while (u16pos + 3 < len) { 69 69 + const a = str.charCodeAt(u16pos); 70 70 + const b = str.charCodeAt(u16pos + 1); 71 71 + const c = str.charCodeAt(u16pos + 2); 72 72 + const d = str.charCodeAt(u16pos + 3); 73 73 + 74 74 + if ((a | b | c | d) >= 0x80) { 75 75 + break jump; 76 76 + } 77 77 + 78 78 + u16pos += 4; 79 79 + u8pos += 4; 80 80 + } 81 81 + 82 82 + while (u16pos < len) { 83 83 + const x = str.charCodeAt(u16pos); 84 84 + 85 85 + if (x >= 0x80) { 86 86 + break jump; 87 87 + } 88 88 + 89 89 + u16pos++; 90 90 + u8pos++; 91 91 + } 92 92 + 93 93 + return u8pos; 94 94 + } 95 95 + 96 96 + while (u16pos < len) { 97 97 + const code = str.charCodeAt(u16pos); 98 98 + 99 99 + if (code < 0x80) { 100 100 + u16pos += 1; 101 101 + u8pos += 1; 102 102 + } else if (code < 0x800) { 103 103 + u16pos += 1; 104 104 + u8pos += 2; 105 105 + } else if (code < 0xd800 || code > 0xdbff) { 106 106 + u16pos += 1; 107 107 + u8pos += 3; 108 108 + } else { 109 109 + u16pos += 2; 110 110 + u8pos += 4; 111 111 + } 112 112 + } 113 113 + 114 114 + return u8pos; 115 115 + }; 116 116 + 117 117 + export const getGraphemeLength = (text: string): number => { 118 118 + const iterator = segmenter.segment(text)[Symbol.iterator](); 119 119 + let count = 0; 120 120 + 121 121 + while (!iterator.next().done) { 122 122 + count++; 123 123 + } 124 124 + 125 125 + return count; 126 126 + };