refactor!: rename indiceSize to sliceSIze

Author: LittleSound

packages/generate/README.md

@@ -44,7 +44,7 @@ const generaterSvg = createGeneraterSVG(new Uint8Array(file.buffer))
 
 const generaterANSI = createGeneraterANSI(new Uint8Array(file.buffer), {
   // Size of each data slice
-  indicesSize: 250,
+  sliceSize: 250,
   // Error correction level
   ecc: 'L',
   // Border width

packages/generate/src/base-generater.ts

@@ -5,7 +5,7 @@ export function createGeneraterWithRender<Result, RenderOptions>(createRender: C
   return (data: Uint8Array, options?: GeneraterBaseOptions<RenderOptions>) => {
     const _options = Object.assign({}, GeneraterDefaultOptions, options)
 
-    const encoder = createEncoder(data, _options.indicesSize, _options.compress)
+    const encoder = createEncoder(data, _options.sliceSize, _options.compress)
 
     let _fountain: ReturnType<typeof encoder.fountain>
 

packages/generate/src/index.ts

@@ -7,3 +7,10 @@ export {
 
   GeneraterDefaultOptions,
 } from './shared'
+
+export {
+  appendFileHeaderMetaToBuffer,
+  appendMetaToBuffer,
+  readFileHeaderMetaFromBuffer,
+  readMetaFromBuffer,
+} from 'luby-transform'

packages/generate/src/shared.ts

@@ -4,13 +4,13 @@ import { blockToBinary, type EncodedBlock } from 'luby-transform'
 export type CreateBlockRenderFn<Result, RenderOptions> = (renderOptions: GeneraterBaseOptions<RenderOptions>) => (block: EncodedBlock) => Result
 
 export type GeneraterBaseOptions<RenderOptions> = {
-  indicesSize?: number
+  sliceSize?: number
   compress?: boolean
   urlPrefix?: string
 } & RenderOptions
 
 export const GeneraterDefaultOptions = {
-  indicesSize: 500,
+  sliceSize: 500,
   urlPrefix: '',
 }
 

packages/generate/test/generate.test.ts

@@ -1,5 +1,11 @@
 import { expect, it } from 'vitest'
+import { createGeneraterQRCodeArray } from '../src/index'
 
-it.todo('should generate test', () => {
-  expect(1).toBe(1)
+// it.todo('should generate test', () => {
+//   expect(1).toBe(1)
+// })
+
+it('generate boolean array', () => {
+  const result = createGeneraterQRCodeArray(new Uint8Array(1).fill(23), 1000)
+  expect(result).toMatchInlineSnapshot()
 })

packages/luby-transform/README.md

@@ -135,7 +135,7 @@ Creates a new `LtEncoder` instance for encoding data.
 #### Parameters
 
 - `data` (`Uint8Array`): The raw data to be encoded.
-- `indicesSize` (`number`): The size of each block.
+- `sliceSize` (`number`): The size of each block.
 - `compress` (`boolean`, optional): Whether to compress the data. Defaults to `true`.
 
 #### Returns

packages/luby-transform/src/decoder.ts

@@ -155,19 +155,19 @@ export class LtDecoder {
       return
     }
 
-    const indicesSize = this.meta.data.length
+    const sliceSize = this.meta.data.length
     const blocks = this.decodedData as Uint8Array[]
     const decodedData = new Uint8Array(this.meta.bytes)
 
     blocks.forEach((block, i) => {
-      const start = i * indicesSize
-      if (start + indicesSize > decodedData.length) {
+      const start = i * sliceSize
+      if (start + sliceSize > decodedData.length) {
         for (let j = 0; j < decodedData.length - start; j++) {
           decodedData[start + j] = block[j]!
         }
       }
       else {
-        decodedData.set(block, i * indicesSize)
+        decodedData.set(block, i * sliceSize)
       }
     })
 

packages/luby-transform/src/encoder.ts

@@ -2,8 +2,8 @@ import type { EncodedBlock } from './shared'
 import { deflate } from 'pako'
 import { getChecksum } from './checksum'
 
-export function createEncoder(data: Uint8Array, indicesSize: number, compress = true): LtEncoder {
-  return new LtEncoder(data, indicesSize, compress)
+export function createEncoder(data: Uint8Array, sliceSize: number, compress = true): LtEncoder {
+  return new LtEncoder(data, sliceSize, compress)
 }
 
 export class LtEncoder {
@@ -15,21 +15,21 @@ export class LtEncoder {
 
   constructor(
     public readonly data: Uint8Array,
-    public readonly indicesSize: number,
+    public readonly sliceSize: number,
     public readonly compress = true,
   ) {
     this.compressed = compress ? deflate(data) : data
-    this.indices = sliceData(this.compressed, indicesSize)
+    this.indices = sliceData(this.compressed, sliceSize)
     this.k = this.indices.length
     this.checksum = getChecksum(this.data, this.k)
     this.bytes = this.compressed.length
   }
 
   createBlock(indices: number[]): EncodedBlock {
-    const data = new Uint8Array(this.indicesSize)
+    const data = new Uint8Array(this.sliceSize)
     for (const index of indices) {
       const indicesIndex = this.indices[index]!
-      for (let i = 0; i < this.indicesSize; i++) {
+      for (let i = 0; i < this.sliceSize; i++) {
         data[i] = data[i]! ^ indicesIndex[i]!
       }
     }