@qr-platform/qr-code.js 0.8.23 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @qr-platform/qr-code-js
 
+## 0.9.0
+
+### Minor Changes
+
+- 06a7b86: added useTemplate, useStyle, build method for builder pattern. setTemplate, setStyle for class instance pattern
+
 ## 0.8.21
 
 ### Patch Changes

package/docs/advanced-examples.md

@@ -446,6 +446,90 @@ const qrBorderElaborate = new QRCodeJs({
 qrBorderElaborate.append(document.getElementById('border-elaborate-container'));
 ```
 
+
+
+--- 
+
+### Builder Pattern Example: Combining Template and Style
+
+Demonstrates using the fluent builder pattern (`useTemplate`, `useStyle`) to combine base settings with specific styles for a complex result.
+
+```typescript
+// Define a base template (could be predefined like 'dots' or 'rounded')
+const baseTemplate = {
+  qrOptions: { errorCorrectionLevel: 'Q' },
+  backgroundOptions: { color: '#f0f0f0' }, // Light grey background
+  margin: 5
+};
+
+// Define a style for specific visual elements - a purple/blue gradient
+const gradientStyle = {
+  dotsOptions: {
+    type: 'classy',
+    gradient: {
+      type: 'linear',
+      rotation: Math.PI / 6, // 30 degrees
+      colorStops: [
+        { offset: 0, color: '#6a11cb' }, // Purple
+        { offset: 1, color: '#2575fc' }  // Blue
+      ]
+    }
+  },
+  cornersSquareOptions: { type: 'dot', color: '#6a11cb' } // Match start color of gradient
+};
+
+// Use the builder pattern to combine template and style
+const qrBuilderExample = QRCodeJs.useTemplate(baseTemplate) // Start with base settings
+  .useStyle(gradientStyle) // Apply the gradient style
+  .options({ data: 'https://example.com/builder-pattern-advanced' }) // Add the data
+
+qrBuilderExample.append(document.getElementById('builder-pattern-container'));
+
+// or using the build method
+
+const qrBuilderExampleWithBuild = QRCodeJs.useTemplate(baseTemplate)
+  .useStyle(gradientStyle)
+  .build();
+
+qrBuilderExampleWithBuild.append(document.getElementById('builder-pattern-container-build'));
+qrBuilderExampleWithBuild.update({ data: 'https://example.com/builder-pattern-advanced' });
+```
+---
+
+### setTemplate and setStyle (Class Instance Pattern)
+
+Demonstrates using the class instance pattern (`setTemplate`, `setStyle`) to combine base settings with specific styles for a complex result.
+
+```typescript
+// Define a base template (could be predefined like 'dots' or 'rounded')
+const baseTemplate = {
+  qrOptions: { errorCorrectionLevel: 'Q' },
+  backgroundOptions: { color: '#f0f0f0' }, // Light grey background
+  margin: 5
+};
+
+// Define a style for specific visual elements - a purple/blue gradient
+const gradientStyle = {
+  dotsOptions: {
+    type: 'classy',
+    gradient: {
+      type: 'linear',
+      rotation: Math.PI / 6, // 30 degrees
+      colorStops: [
+        { offset: 0, color: '#6a11cb' }, // Purple
+        { offset: 1, color: '#2575fc' }  // Blue
+      ]
+    }
+  },
+  cornersSquareOptions: { type: 'dot', color: '#6a11cb' } // Match start color of gradient
+};
+
+// Use the builder pattern to combine template and style
+const qrBuilderExample = new QRCodeJs({ data: 'https://example.com/class-instance-pattern-advanced' })
+  .setTemplate(baseTemplate) // Start with 'classy' template
+  .setStyle(gradientStyle) // Apply the gradient style
+  .append(document.getElementById('builder-pattern-container'));
+```
 ---
 
 ### Scan Validation (Premium Feature)

package/docs/api-reference-guide.md

@@ -86,9 +86,13 @@ qrCode.append(document.getElementById('qr-container'));
 | `serialize`         | `inverted?: boolean`                                                       | Converts the QR code to an SVG string. Returns `Promise<string \| undefined>`. |
 | `download`          | `downloadOptions?: { name?: string; extension: 'svg' \| 'png' \| 'jpeg' \| 'webp' }, canvasOptions?: CanvasOptions` | Downloads the QR code as a file. Returns `Promise<void>`.                   |
 | `update`            | `options?: RecursivePartial<Options>`                                      | Updates the QR code with new options. Returns `void`.                       |
+| `setTemplate`       | `templateNameOrOptions: string \| RecursivePartial<Options>` | Sets a global default template for subsequent instances. Returns `void`.    |\n| `useTemplate`       | `templateNameOrOptions: string \| RecursivePartial<Options>` | Initiates a builder pattern pre-configured with a template. Returns `QRCodeBuilder`. |
 | `validateScanning`  | `validatorId?: string, debug?: boolean`                                    | **(Premium method)** Validates that the QR code is scannable. Returns `Promise<ScanValidatorResponse>`. |
 
 ---
+
+| `useStyle`          | `styleNameOrOptions: string \| StyleOptions`                               | Creates a `QRCodeBuilder` instance initialized with a specific style. Returns `QRCodeBuilder`. |
+| `useTemplate`       | `templateNameOrOptions: string \| RecursivePartial<Options>`             | Creates a `QRCodeBuilder` instance initialized with a specific template. Returns `QRCodeBuilder`. |
 <a id="borderoptions"></a>
 ### borderOptions Options 
 
@@ -244,6 +248,40 @@ enum ImageMode {
 
 ---
 
+
+
+---
+
+### QRCodeBuilder Class
+
+The `QRCodeBuilder` provides a fluent interface for configuring and creating `QRCodeJs` instances, often starting with a template or style.
+
+**Usage:**
+
+```typescript
+// Start with a template
+const qr1 = QRCodeJs.useTemplate('rounded')
+  .options({ data: 'Data for rounded template' })
+  .build();
+
+// Start with a style
+const qr2 = QRCodeJs.useStyle({ dotsOptions: { type: 'dots', color: 'blue' } })
+  .options({ data: 'Data for blue dots style' })
+  .build();
+
+// Chain template and style
+const qr3 = QRCodeJs.useTemplate('basic')
+  .useStyle({ backgroundOptions: { color: '#eee' } })
+  .options({ data: 'Data with template and style' })
+  .build();
+```
+
+| Method        | Parameters                                                                 | Description                                                                                                |
+| :------------ | :------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------- |
+| `useTemplate` | `templateNameOrOptions: string \| RecursivePartial<Options>`             | Applies a template's options to the current configuration. Options from subsequent calls take precedence. Returns `this`. |
+| `useStyle`    | `styleNameOrOptions: string \| StyleOptions`                               | Applies style options (mapping them to `Options`) to the current configuration. Returns `this`.            |
+| `options`     | `options: RecursivePartial<Options>`                                       | Merges the provided `Options` into the current configuration and returns the final `QRCodeJs` instance.    |
+| `build`       | -                                                                          | Creates and returns the final `QRCodeJs` instance based on the accumulated configuration.                  |
 ### See Also
 - [QRCode.js Documentation](./documentation.md#start)
 - [Quick References Guide](./quick-references-guide.md#start)

package/docs/documentation.md

@@ -997,6 +997,63 @@ When using the basic border features in the free version, the library will autom
   });
   ```
 
+
+## Using Templates
+
+Templates offer a convenient way to apply a consistent set of styling and configuration options across multiple QR codes. QRCode.js provides two primary methods for working with templates:
+
+### Setting Global Defaults (`setTemplate`)
+
+The static method `QRCodeJs.setTemplate(templateNameOrOptions)` allows you to define a default template that will be automatically applied to all `QRCodeJs` instances created *after* the template is set. This is useful for establishing a baseline style for your application.
+
+- You can provide the name of a predefined template (e.g., `'rounded'`, `'dots'`, `'classy'`).
+- You can provide a custom partial options object (`RecursivePartial<Options>`).
+- Any options provided during the instantiation of `new QRCodeJs({...})` will override the global template defaults for that specific instance.
+- Call `QRCodeJs.setTemplate(null)` or `QRCodeJs.setTemplate('basic')` to reset to the default behavior.
+
+```typescript
+// Set a global template
+QRCodeJs.setTemplate('dots');
+
+// This QR code will use the 'dots' template
+const qr1 = new QRCodeJs({ data: 'Uses global dots template' });
+
+// Override the global template's color for this instance
+const qr2 = new QRCodeJs({
+  data: 'Overrides global dots color',
+  dotsOptions: { color: '#FF4500' } // OrangeRed
+});
+
+// Reset to basic template
+QRCodeJs.setTemplate('basic');
+```
+
+### Using the Builder Pattern (`useTemplate`)
+
+The static method `QRCodeJs.useTemplate(templateNameOrOptions)` initiates a builder pattern. It returns a builder object pre-configured with the specified template (either by name or by providing a partial options object directly). 
+
+- This method **does not** set a global default.
+- You **must** chain this call with the `.options({...})` method on the returned builder.
+- The `.options()` method takes the final configuration, including the required `data` property and any overrides specific to this instance.
+
+```typescript
+// Start with the 'rounded' template, provide data and override color
+const qrBuilder1 = QRCodeJs.useTemplate('rounded').options({
+  data: 'Built with rounded template',
+  dotsOptions: { color: '#007BFF' } // Blue override
+});
+
+// Start with inline custom options, then provide data
+const qrBuilder2 = QRCodeJs.useTemplate({
+  shape: 'circle',
+  dotsOptions: { type: 'star', color: '#DC3545' } // Red stars
+}).options({
+  data: 'Built with inline circle/star template'
+});
+```
+
+Choosing between `setTemplate` and `useTemplate` depends on whether you need a persistent global default or a one-off configuration based on a template.
+
 ## Complete Examples
 
 ### Basic QR Code with Custom Dots
@@ -1306,6 +1363,23 @@ qrCode.validateScanning(
 
 ### Static Methods (License Management)
 
+
+
+#### `useTemplate()`
+
+Creates a `QRCodeBuilder` instance initialized with a specific template.
+
+```typescript
+QRCodeJs.useTemplate(templateNameOrOptions: string | RecursivePartial<Options>): QRCodeBuilder
+```
+
+#### `useStyle()`
+
+Creates a `QRCodeBuilder` instance initialized with a specific style.
+
+```typescript
+QRCodeJs.useStyle(styleNameOrOptions: string | StyleOptions): QRCodeBuilder
+```
 These methods are called directly on the `QRCodeJs` class (or `QRCodeJs` imported from `qrcode-js/node`).
 
 #### `initializeIfNeeded()`
@@ -1356,6 +1430,114 @@ Sets the URL endpoint for license key validation.
 QRCodeJs.setLicenseUrl(url: string): void
 ```
 
+#### `setTemplate()`
+
+Sets a global default template for subsequent `QRCodeJs` instances.
+
+```typescript
+QRCodeJs.setTemplate(templateNameOrOptions: string | RecursivePartial<Options>): void
+```
+
+#### `useTemplate()`
+
+Initiates a builder pattern pre-configured with a template.
+
+```typescript
+QRCodeJs.useTemplate(templateNameOrOptions: string | RecursivePartial<Options>): QRCodeBuilder
+```
+
+#### `setStyle()`
+
+Sets a global default style for subsequent `QRCodeJs` instances.
+
+```typescript
+QRCodeJs.setStyle(styleNameOrOptions: string | RecursivePartial<StyleOptions>): void
+```
+
+#### `useStyle()`
+
+Initiates a builder pattern pre-configured with a style.
+
+```typescript
+QRCodeJs.useTemplate(styleNameOrOptions: string | RecursivePartial<StyleOptions>): QRCodeBuilder
+```
+
+## Fluent Builder Pattern (`useTemplate`, `useStyle`, `build`)
+
+QRCode.js offers a fluent builder pattern for a more readable and chainable way to configure and create QR codes, especially when combining templates, styles, and custom options.
+
+### Overview
+
+Instead of passing all options to the constructor, you can start with a base template or style using `QRCodeJs.useTemplate()` or `QRCodeJs.useStyle()`. These methods return a `QRCodeBuilder` instance. You can then chain further `.useTemplate()`, `.useStyle()`, and finally `.options()` or `.build()` to finalize the configuration.
+
+- `QRCodeJs.useTemplate(template)`: Starts a builder with a predefined or custom template.
+- `QRCodeJs.useStyle(style)`: Starts a builder and applies a predefined or custom style.
+- `.useTemplate(template)` (on builder): Applies another template. Options merge, with later calls overriding earlier ones.
+- `.useStyle(style)` (on builder): Applies another style. Options merge, with later calls overriding earlier ones.
+- `.options(options)` (on builder): Merges final specific options and returns the `QRCodeJs` instance.
+- `.build()` (on builder, optional method if options(options) is NOT called): Creates the `QRCodeJs` instance with the accumulated configuration.
+
+### How `useStyle` and `useTemplate` Work Together (Builder Pattern)
+
+You can chain `useTemplate` and `useStyle` calls. The options are merged progressively. If both a template and a style define the same option (e.g., `dotsOptions.color`), the option from the *last* applied template or style in the chain will take precedence.
+
+### Examples
+
+**1. Start with a Template, Add Options:**
+
+```typescript
+const qrFromTemplate = QRCodeJs.useTemplate('rounded') // Start with 'rounded' template
+  .options({ // Merge specific options
+    data: 'Data for rounded QR',
+    margin: 10
+  })
+  .build(); // Build the final instance
+
+qrFromTemplate.append(document.getElementById('qr-container-1'));
+```
+
+**2. Start with a Style, Add Options:**
+
+```typescript
+const myStyle = {
+  dotsOptions: { type: 'dots', color: '#FF6347' }, // Tomato dots
+  backgroundOptions: { color: '#F0F8FF' } // AliceBlue background
+};
+
+const qrFromStyle = QRCodeJs.useStyle(myStyle) // Start with custom style
+  .options({ // Merge specific options
+    data: 'Data for styled QR',
+    qrOptions: { errorCorrectionLevel: 'H' }
+  })
+  .build();
+
+qrFromStyle.append(document.getElementById('qr-container-2'));
+```
+
+**3. Chain Template and Style:**
+
+```typescript
+const qrCombined = QRCodeJs.useTemplate('dots') // Start with 'dots' template (black dots)
+  .useStyle({ dotsOptions: { color: '#4682B4' } }) // Apply style, overriding dot color to SteelBlue
+  .options({ data: 'Template + Style' })
+  .build();
+
+qrCombined.append(document.getElementById('qr-container-3'));
+```
+
+**4. Build without final options:**
+
+```typescript
+// Assume 'data' is part of the template or style
+const qrBuildDirectly = QRCodeJs.useTemplate({ 
+    data: 'Data in template',
+    dotsOptions: { type: 'square' }
+  })
+  .build(); // Build directly if all options are set
+
+qrBuildDirectly.append(document.getElementById('qr-container-4'));
+```
+
 ## FAQ
 
 ### General Questions

package/docs/examples.md

@@ -35,69 +35,187 @@ if (container && qrCode.svgElement) {
 }
 ```
 
----
-
 ## Using Templates
 
-Templates provide a way to apply a predefined set of options easily. You can use built-in templates or define your own.
+Templates provide convenient ways to apply predefined sets of options. QRCode.js offers two main approaches: setting a global template default with `setTemplate` and using a builder pattern with `useTemplate`.
+
+### Setting Global Defaults with `setTemplate`
 
-**Example 1: Using a Predefined Template ('rounded')**
+The `QRCodeJs.setTemplate()` static method allows you to define default options that will apply to all subsequently created `QRCodeJs` instances until the template is changed or cleared.
+
+**Example 1: Setting a Predefined Global Template ('rounded')**
 
 ```javascript
-// filepath: /Users/kurdin/projects/qr-platform/qr-code-js/docs/examples.md
+// Import the library (adjust path as needed)
+import { QRCodeJs, Options } from '@qr-platform/qr-code.js';
 
-// Set the 'rounded' template globally for subsequent instances
+// Set the 'rounded' template globally
 QRCodeJs.setTemplate('rounded');
 
-const qrUsingTemplate = new QRCodeJs({
-  data: 'Uses the rounded template'
+// This instance will use the 'rounded' template defaults
+const qrGlobalRounded = new QRCodeJs({
+  data: 'Uses the global rounded template'
+});
+qrGlobalRounded.append(document.getElementById('global-template-rounded-container'));
+
+// This instance will also use 'rounded'
+const qrAnotherRounded = new QRCodeJs({
+  data: 'Also uses rounded template'
 });
-qrUsingTemplate.append(document.getElementById('template-rounded-container'));
+qrAnotherRounded.append(document.getElementById('another-rounded-container'));
 
-// Note: The template remains set until changed or cleared.
+// Note: The global template remains active until changed or cleared.
+// To clear: QRCodeJs.setTemplate(null); or QRCodeJs.setTemplate('basic');
 ```
 
-**Example 2: Using a Custom Template Object**
+**Example 2: Setting a Custom Global Template Object**
 
 ```javascript
-// filepath: /Users/kurdin/projects/qr-platform/qr-code-js/docs/examples.md
-
-const myCustomTemplate = {
+const myGlobalTemplate = {
   dotsOptions: { type: 'classy', color: '#8A2BE2' }, // BlueViolet classy dots
   backgroundOptions: { color: '#FAFAFA' }, // Off-white background
   cornersSquareOptions: { type: 'dot', color: '#8A2BE2' }
 };
 
 // Set the custom template globally
-QRCodeJs.setTemplate(myCustomTemplate);
+QRCodeJs.setTemplate(myGlobalTemplate);
 
-const qrCustomTemplate = new QRCodeJs({
-  data: 'Uses a custom template object'
+const qrCustomGlobal = new QRCodeJs({
+  data: 'Uses a custom global template'
 });
-qrCustomTemplate.append(document.getElementById('template-custom-container'));
+qrCustomGlobal.append(document.getElementById('custom-global-container'));
 ```
 
-**Example 3: Overriding Template Options**
+**Example 3: Overriding Global Template Options**
 
 ```javascript
-// filepath: /Users/kurdin/projects/qr-platform/qr-code-js/docs/examples.md
-
 // Assume 'dots' template is set globally
 QRCodeJs.setTemplate('dots');
 
-const qrOverrideTemplate = new QRCodeJs({
-  data: 'Overrides template color',
-  // This color will override the black color from the 'dots' template
+const qrOverrideGlobal = new QRCodeJs({
+  data: 'Overrides global template color',
+  // This color overrides the black color from the 'dots' template
   dotsOptions: { color: '#FF4500' } // OrangeRed dots
 });
-qrOverrideTemplate.append(document.getElementById('template-override-container'));
+qrOverrideGlobal.append(document.getElementById('override-global-container'));
+```
 
-// Remember to clear the template if you don't want it for subsequent QRs
-// QRCodeJs.setTemplate(null); // Or set back to 'basic' or another template
+### Using the Builder Pattern with `useTemplate`
+
+The `QRCodeJs.useTemplate()` static method provides a flexible builder pattern. It returns a builder instance pre-configured with a template (by name or by providing options directly). You *must* then call the `.options()` method on the builder to provide the required `data` and any final overrides. This approach does *not* affect the global template setting.
+
+**Example 4: Using `useTemplate` with a Predefined Name ('dots')**
+
+```javascript
+// Import the library (adjust path as needed)
+import { QRCodeJs, Options } from '@qr-platform/qr-code.js';
+
+// Start with the 'dots' template, then provide data and overrides
+const qrBuilderDots = QRCodeJs.useTemplate('dots').options({
+  data: 'Built with dots template',
+  dotsOptions: { color: '#20C997' } // Override color to Teal
+});
+qrBuilderDots.append(document.getElementById('builder-dots-container'));
+
+// This instance is unaffected by the useTemplate call above
+const qrBasicAfterBuilder = new QRCodeJs({ data: 'Basic QR' });
+qrBasicAfterBuilder.append(document.getElementById('basic-after-builder-container'));
+```
+
+**Example 5: Using `useTemplate` with Custom Options**
+
+```javascript
+const myInlineTemplate = {
+  dotsOptions: { type: 'star', color: '#DC3545' }, // Red stars
+  shape: 'circle'
+};
+
+// Start with custom options, then provide data
+const qrBuilderCustom = QRCodeJs.useTemplate(myInlineTemplate).options({
+  data: 'Built with inline custom template (stars)'
+});
+qrBuilderCustom.append(document.getElementById('builder-custom-container'));
 ```
 
+**Example 6: Overriding `useTemplate` Options in `.options()`**
+
+```javascript
+// Start with the 'classy' template
+const qrBuilderOverride = QRCodeJs.useTemplate('classy').options({
+  data: 'Overrides classy template color',
+  // This color overrides the black from the 'classy' template
+  dotsOptions: { color: '#6f42c1' } // Indigo
+});
+qrBuilderOverride.append(document.getElementById('builder-override-container'));
+```
 ---
 
+## Using the Builder Pattern (`useTemplate`, `useStyle`, `build`)
+
+The builder pattern provides a fluent way to configure QR codes, often starting with a template or style.
+
+**Example 1: Using `useTemplate` with a Predefined Template ('rounded')**
+
+```javascript
+// filepath: /Users/kurdin/projects/qr-platform/qr-code-js/docs/examples.md
+
+const qrFromTemplate = QRCodeJs.useTemplate('rounded') // Start builder with 'rounded' template
+  .options({ data: 'Uses the rounded template via builder' }) // Add data
+
+qrFromTemplate.append(document.getElementById('template-rounded-container'));
+```
+
+**Example 2: Using `useTemplate` with a Custom Template Object**
+
+```javascript
+// filepath: /Users/kurdin/projects/qr-platform/qr-code-js/docs/examples.md
+
+const myCustomTemplate = {
+  dotsOptions: { type: 'classy', color: '#8A2BE2' }, // BlueViolet classy dots
+  backgroundOptions: { color: '#FAFAFA' }, // Off-white background
+  cornersSquareOptions: { type: 'dot', color: '#8A2BE2' }
+};
+
+const qrCustomTemplate = QRCodeJs.useTemplate(myCustomTemplate) // Start builder with custom template
+  .build();
+
+// update the data
+qrCustomTemplate.update({ data: 'Uses a custom template object' });
+qrCustomTemplate.append(document.getElementById('template-custom-container'));
+```
+
+**Example 3: Using `useStyle`**
+
+```javascript
+// filepath: /Users/kurdin/projects/qr-platform/qr-code-js/docs/examples.md
+
+const myStyle = {
+  dotsOptions: { type: 'dots', color: '#FF4500' }, // OrangeRed dots
+  backgroundOptions: { color: '#FFF0E1' } // SeaShell background
+};
+
+const qrFromStyle = QRCodeJs.useStyle(myStyle) // Start builder with style
+  .options({ data: 'Uses a style via builder' })
+  .build();
+
+qrFromStyle.append(document.getElementById('style-container'));
+```
+
+**Example 4: Chaining `useTemplate` and `useStyle`**
+
+```javascript
+// filepath: /Users/kurdin/projects/qr-platform/qr-code-js/docs/examples.md
+
+// Start with 'dots' template (black dots), then apply a style to change color
+const qrChained = QRCodeJs.useTemplate('dots')
+  .useStyle({ dotsOptions: { color: '#20B2AA' } }) // LightSeaGreen dots
+  .options({ data: 'Template overridden by Style' })
+  .build();
+
+qrChained.append(document.getElementById('template-style-chain-container'));
+```
+
+---
 
 ## Examples by Option Group
 

package/docs/template-update-plan.md

@@ -0,0 +1,53 @@
+# Plan: Update Documentation for `useTemplates` Feature
+
+**Objective:** Update the documentation in the `docs` directory to accurately reflect the template features, including modifying `useTemplate` to accept options directly and ensuring both `setTemplate` and the updated `useTemplate` builder pattern are correctly documented.
+
+## Phase 1: Code Modification (To be done in Code Mode)
+
+1.  **Modify `useTemplate` Signature:**
+    *   In `src/index.ts`, change `QRCodeJs.useTemplate(templateName: string)` to `QRCodeJs.useTemplate(templateNameOrOptions: string | RecursivePartial<Options>)`.
+    *   In `src/node.ts`, make the same change: `QRCodeJs.useTemplate(templateNameOrOptions: string | RecursivePartial<Options>)`.
+2.  **Modify `QRCodeBuilder` Constructor:**
+    *   In `src/index.ts`, update the `QRCodeBuilder` constructor to handle the `templateNameOrOptions` parameter. If it's a string, look up the template; if it's an object, use it directly as the base configuration.
+    *   In `src/node.ts`, make the corresponding change to the `QRCodeBuilder` constructor.
+
+## Phase 2: Documentation Update (Reflecting Both Methods)
+
+1.  **`docs/examples.md`:**
+    *   **`setTemplate` Section:** Ensure this section accurately explains setting global template defaults.
+    *   **`useTemplate` Section:** Update this section to:
+        *   Explain the builder pattern: `QRCodeJs.useTemplate(...).options({...})`.
+        *   Show examples using a template name: `useTemplate('rounded').options(...)`.
+        *   Show examples providing options directly: `useTemplate({ dotsOptions: {...} }).options(...)`.
+        *   Clarify that `.options()` is always needed to provide `data` and final overrides.
+
+2.  **`docs/usage-guide.md`:**
+    *   **`setTemplate`:** Verify its documentation is correct.
+    *   **`useTemplate`:** Update its description to reflect the new signature (`string | RecursivePartial<Options>`) and explain its use in the builder pattern.
+    *   **Static Methods List:** Ensure both `setTemplate` and the updated `useTemplate` are listed correctly.
+
+3.  **`docs/documentation.md`:**
+    *   **Verify `setTemplate`:** Ensure it's correctly described throughout (main body, API reference, FAQ).
+    *   **Update `useTemplate`:** Update its description in the API reference section to show the new signature and explain the builder pattern usage.
+
+4.  **`docs/api-reference-guide.md`:**
+    *   **Verify `setTemplate`:** Ensure it's listed correctly in the methods table.
+    *   **Update `useTemplate`:** Update the parameter type to `string | RecursivePartial<Options>` and clarify its role in initiating the builder pattern.
+
+5.  **Review Other Files:** Briefly check `advanced-examples.md`, `typescript-types-definitions.md`, and `license-management.md` for consistency regarding both `setTemplate` and the updated `useTemplate`.
+
+## Conceptual Flow Diagram (`useTemplate`)
+
+```mermaid
+graph LR
+    subgraph useTemplate Flow
+        A[User Code] --> B{QRCodeJs.useTemplate(nameOrOptions)};
+        B -- name --> C[Lookup Template];
+        B -- options --> D[Use Provided Options];
+        C --> E{QRCodeBuilder Instance};
+        D --> E;
+        A --> F(Specific Options e.g., data);
+        E --> G(builder.options(Specific Options));
+        F --> G;
+        G --> H(Final QRCodeJs Instance);
+    end