+1 -1

probe/pop-improved.js

View file Reviewed

··· 1 1 - const str = "😀".repeat(100) 1 1 + const str = "😀".repeat(10) 2 2 3 3 const segmenter = new Intl.Segmenter(); 4 4 function fold_graphemes(str, state, fun) {

+1 -1

probe/pop-rust.mjs

View file Reviewed

··· 1 1 import { graphemeSegments } from 'unicode-segmenter/grapheme'; 2 2 3 3 - const str = "😀".repeat(100) 3 3 + const str = "😀".repeat(10) 4 4 5 5 function fold_graphemes(str, state, fun) { 6 6 for(const { segment: grapheme } of graphemeSegments(str)) {

+336 -5

src/string_width.gleam

View file Reviewed

··· 252 252 253 253 // -- TRUNCATE / PAD ----------------------------------------------------------- 254 254 255 255 - // "make lines be width" 256 256 - // line to short? align left/right/center/stretch 257 257 - // line to long? truncate/wrap 258 258 - // break at? shys/whitespace/unicode word boudnaries/grahpeme boundaries? this is hard 259 259 - // justify vs text align 255 255 + /// Limit the dimensions of a string, either by wrapping on white space 256 256 + /// characters, or by truncating the last line and appending an ellipsis. 257 257 + /// 258 258 + /// The lines of the resulting string are left aligned and are at most `columns` 259 259 + /// wide. If a single word is longer than the maximum allowed line width, the 260 260 + /// word is broken into 2 pieces at the grapheme level. If the string gets 261 261 + /// truncated, this function will keep collecting ANSI sequences to make sure 262 262 + /// all formatting is preserved. 263 263 + /// 264 264 + /// A commonly used ellipsis character is `"…"`, also known as 265 265 + /// U+2026 HORIZONTAL ELLIPSIS. 266 266 + /// 267 267 + /// ### Examples 268 268 + /// 269 269 + /// ```gleam 270 270 + /// limit("Hello World", Size(rows: 1, columns: 10), ellipsis: "...") 271 271 + /// // --> "Hello W..." 272 272 + /// 273 273 + /// limit("Hello World", Size(rows: 2, columns: 5), ellipsis: "...") 274 274 + /// // --> "Hello\nWorld" 275 275 + /// ``` 276 276 + pub fn limit( 277 277 + str: String, 278 278 + to max_size: Size, 279 279 + ellipsis ellipsis: String, 280 280 + ) -> String { 281 281 + limit_with(str, max_size, default_options, ellipsis) 282 282 + } 283 283 + 284 284 + type LimitState { 285 285 + LimitState( 286 286 + str: String, 287 287 + row: Int, 288 288 + col: Int, 289 289 + spaces: String, 290 290 + spaces_width: Int, 291 291 + non_spaces: String, 292 292 + non_spaces_width: Int, 293 293 + overflow: String, 294 294 + overflow_width: Int, 295 295 + ) 296 296 + } 297 297 + 298 298 + fn limit_state_col(state: LimitState) { 299 299 + state.col + state.spaces_width + state.non_spaces_width + state.overflow_width 300 300 + } 301 301 + 302 302 + /// Like `limit`, but also customise the options used for measuring. 303 303 + pub fn limit_with( 304 304 + str: String, 305 305 + to max_size: Size, 306 306 + using options: Options, 307 307 + ellipsis ellipsis: String, 308 308 + ) -> String { 309 309 + let ellipsis_width = line_with(ellipsis, options) 310 310 + 311 311 + let initial = 312 312 + LimitState( 313 313 + str: "", 314 314 + row: 0, 315 315 + col: 0, 316 316 + spaces: "", 317 317 + spaces_width: 0, 318 318 + non_spaces: "", 319 319 + non_spaces_width: 0, 320 320 + overflow: "", 321 321 + overflow_width: 0, 322 322 + ) 323 323 + 324 324 + // we encode a few states, but we do it this way such that spread works... 325 325 + // - if state.row == max_size.rows, we have reached the end and should do nothing 326 326 + // - if we have oveflow, we are at the last line and stuff doesn't fit. 327 327 + // - if we have non_spaces or overflow, we are collecting word characters. 328 328 + // - if we do not, we are collecting spaces _before_ a word. 329 329 + // - on the first space we collect, if we notice that we have word characters, 330 330 + // we try to push this word into the accumulator. 331 331 + // if it doesn't fit on the last line, we have overflow, and can append the ellipsis. 332 332 + // afterwards, we set row = max_sie.rows to indicate we are finished. 333 333 + let push_space = fn(state: LimitState, piece: String, width: Int) { 334 334 + let new_col = limit_state_col(state) 335 335 + 336 336 + // make sure we definitely have room for the ellipsis on the last line 337 337 + let max_col = case state.row + 1 >= max_size.rows { 338 338 + True -> max_size.columns - ellipsis_width 339 339 + False -> max_size.columns 340 340 + } 341 341 + 342 342 + case state.non_spaces == "" && state.overflow == "" { 343 343 + // we do not have non-spaces, so we are still collecting spaces. 344 344 + True -> 345 345 + case state.str { 346 346 + // skip spaces at the start, since we skip them at the end. 347 347 + "" -> state 348 348 + _ -> 349 349 + LimitState( 350 350 + ..state, 351 351 + spaces: state.spaces <> piece, 352 352 + spaces_width: state.spaces_width + width, 353 353 + ) 354 354 + } 355 355 + 356 356 + // we have non-spaces, so we want to push this word into the accumulator 357 357 + // and then start again collecting spaces. 358 358 + False -> 359 359 + // would it fit into the line just normally? 360 360 + case new_col <= max_col { 361 361 + True -> { 362 362 + // it fits normally, nothing special required! 363 363 + let str = 364 364 + state.str <> state.spaces <> state.non_spaces <> state.overflow 365 365 + // does our new space fit though? 366 366 + case state.row + 1 >= max_size.rows && new_col + width > max_col { 367 367 + False -> 368 368 + LimitState( 369 369 + str:, 370 370 + row: state.row, 371 371 + col: new_col, 372 372 + spaces: piece, 373 373 + spaces_width: width, 374 374 + non_spaces: "", 375 375 + non_spaces_width: 0, 376 376 + overflow: "", 377 377 + overflow_width: 0, 378 378 + ) 379 379 + 380 380 + True -> 381 381 + LimitState( 382 382 + str:, 383 383 + row: state.row, 384 384 + col: new_col, 385 385 + spaces: "", 386 386 + spaces_width: 0, 387 387 + non_spaces: "", 388 388 + non_spaces_width: 0, 389 389 + overflow: piece, 390 390 + overflow_width: width, 391 391 + ) 392 392 + } 393 393 + } 394 394 + 395 395 + False -> 396 396 + // it doesn't; if we are at the last line, truncate. else, wrap. 397 397 + case state.row + 1 >= max_size.rows { 398 398 + True -> 399 399 + // we are at the last line. 400 400 + LimitState( 401 401 + ..state, 402 402 + str: state.str <> state.spaces <> state.non_spaces <> ellipsis, 403 403 + row: state.row + 1, 404 404 + ) 405 405 + 406 406 + False -> 407 407 + LimitState( 408 408 + str: state.str <> "\n" <> state.non_spaces <> state.overflow, 409 409 + row: state.row + 1, 410 410 + col: state.non_spaces_width + state.overflow_width, 411 411 + spaces: piece, 412 412 + spaces_width: width, 413 413 + non_spaces: "", 414 414 + non_spaces_width: 0, 415 415 + overflow: "", 416 416 + overflow_width: 0, 417 417 + ) 418 418 + } 419 419 + } 420 420 + } 421 421 + } 422 422 + 423 423 + let state = { 424 424 + // TODO: this may be fold_raw-able 425 425 + use state, piece <- fold_with(str, options, initial) 426 426 + case state.row >= max_size.rows { 427 427 + // reached the end, but we still want to collect ansi sequences 428 428 + True -> 429 429 + case is_ansi_component(piece.piece, options) { 430 430 + True -> LimitState(..state, str: state.str <> piece.piece) 431 431 + False -> state 432 432 + } 433 433 + 434 434 + False -> 435 435 + case piece.piece { 436 436 + // Line break that we recognise as such 437 437 + "\n" | "\r\n" -> { 438 438 + let state = push_space(state, "", 0) 439 439 + LimitState( 440 440 + ..state, 441 441 + str: state.str <> "\n", 442 442 + row: state.row + 1, 443 443 + col: 0, 444 444 + ) 445 445 + } 446 446 + 447 447 + "\t" 448 448 + | // White_Space=Y, Non line-break 449 449 + " " 450 450 + | "\u{a0}" 451 451 + | "\u{1680}" 452 452 + | "\u{2000}" 453 453 + | "\u{2001}" 454 454 + | "\u{2002}" 455 455 + | "\u{2003}" 456 456 + | "\u{2004}" 457 457 + | "\u{2005}" 458 458 + | "\u{2006}" 459 459 + | "\u{2007}" 460 460 + | "\u{2008}" 461 461 + | "\u{2009}" 462 462 + | "\u{200a}" 463 463 + | "\u{202f}" 464 464 + | "\u{205f}" 465 465 + | "\u{3000}" -> push_space(state, piece.piece, piece.width) 466 466 + 467 467 + // not a space or a line break 468 468 + _ -> { 469 469 + let max_col = case state.row + 1 >= max_size.rows { 470 470 + True -> max_size.columns - ellipsis_width 471 471 + False -> max_size.columns 472 472 + } 473 473 + 474 474 + case limit_state_col(state) + piece.width > max_col { 475 475 + True -> { 476 476 + // these non_space characters no longer fit the line, 477 477 + // but what if overflow is too long as well? 478 478 + case 479 479 + state.non_spaces_width + state.overflow_width + piece.width 480 480 + > max_size.columns 481 481 + { 482 482 + True -> 483 483 + // it _is_! do we have room for another row? 484 484 + case state.row + 1 < max_size.rows { 485 485 + True -> 486 486 + LimitState( 487 487 + str: state.str 488 488 + <> state.spaces 489 489 + <> state.non_spaces 490 490 + <> "\n", 491 491 + col: 0, 492 492 + row: state.row + 1, 493 493 + non_spaces: state.overflow <> piece.piece, 494 494 + non_spaces_width: state.overflow_width + piece.width, 495 495 + spaces: "", 496 496 + spaces_width: 0, 497 497 + overflow: "", 498 498 + overflow_width: 0, 499 499 + ) 500 500 + 501 501 + False -> 502 502 + // no, word to long this is the last row, sorry. 503 503 + LimitState( 504 504 + ..state, 505 505 + str: state.str 506 506 + <> state.spaces 507 507 + <> state.non_spaces 508 508 + <> ellipsis, 509 509 + row: state.row + 1, 510 510 + ) 511 511 + } 512 512 + 513 513 + False -> 514 514 + LimitState( 515 515 + ..state, 516 516 + overflow: state.overflow <> piece.piece, 517 517 + overflow_width: state.overflow_width + piece.width, 518 518 + ) 519 519 + } 520 520 + } 521 521 + 522 522 + False -> 523 523 + // everything's fine and normal :) 524 524 + LimitState( 525 525 + ..state, 526 526 + non_spaces: state.non_spaces <> piece.piece, 527 527 + non_spaces_width: state.non_spaces_width + piece.width, 528 528 + ) 529 529 + } 530 530 + } 531 531 + } 532 532 + } 533 533 + } 534 534 + 535 535 + case 536 536 + state.row >= max_size.rows 537 537 + || { state.non_spaces == "" && state.overflow == "" } 538 538 + { 539 539 + // either reached the end, or we have no word characters left. 540 540 + True -> state.str 541 541 + False -> { 542 542 + let new_col = limit_state_col(state) 543 543 + // would it fit into the line just normally? 544 544 + case new_col <= max_size.columns { 545 545 + True -> state.str <> state.spaces <> state.non_spaces <> state.overflow 546 546 + 547 547 + False -> 548 548 + // it doesn't; if we are at the last line, truncate. else, wrap. 549 549 + case state.row + 1 >= max_size.rows { 550 550 + True -> state.str <> state.spaces <> state.non_spaces <> ellipsis 551 551 + False -> state.str <> "\n" <> state.non_spaces <> state.overflow 552 552 + } 553 553 + } 554 554 + } 555 555 + } 556 556 + } 557 557 + 558 558 + /// Replace all tab characters found in the string with the amount of spaces 559 559 + /// that this tab would have had otherwise. 560 560 + /// 561 561 + /// This makes it save to prepend to a line, without changing the spacing produced 562 562 + /// by tabs anymore. 563 563 + /// 564 564 + /// ### Examples 565 565 + /// 566 566 + /// ```gleam 567 567 + /// tabs_to_spaces("Hello\tWorld") 568 568 + /// // --> "Hello World" // 3 spaces 569 569 + /// ``` 570 570 + pub fn tabs_to_spaces(str: String) -> String { 571 571 + tabs_to_spaces_with(str, default_options) 572 572 + } 573 573 + 574 574 + /// Like `tabs_to_spaces`, but customise the opttions as well. 575 575 + /// 576 576 + /// **NB:** You can use `tab_offset` and `tab_width` to change the measure of 577 577 + /// tab characters inside the string! 578 578 + /// 579 579 + /// ```gleam 580 580 + /// let options = new() |> tab_width(4) 581 581 + /// tabs_to_spaces_with("hi\tcutie~", options) 582 582 + /// // --> "hi cutie~" 583 583 + /// ``` 584 584 + pub fn tabs_to_spaces_with(str: String, using options: Options) -> String { 585 585 + use acc, piece <- fold_with(str, options, from: "") 586 586 + case piece.piece { 587 587 + "\t" -> acc <> string.repeat(" ", piece.width) 588 588 + _ -> acc <> piece.piece 589 589 + } 590 590 + } 260 591 261 592 // fold over words? (handle shy hyphens/soft breaks etc) 262 593 // I do not want to implement full unicode word segmentation here though