@rtorcato/repo-tooling 2.59.0

package/dist/cli/generators/readme.js

@@ -0,0 +1,268 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { buildBadgeBlock, parseRepository } from './badges.js';
+export async function generateReadme(config, targetDir) {
+    const readmePath = path.join(targetDir, 'README.md');
+    const badges = config.badges ? await buildReadmeBadgeBlock(config, targetDir) : '';
+    const readme = `# ${config.projectName}
+${badges ? `\n${badges}\n` : ''}
+> Generated with [@rtorcato/repo-tooling](https://www.npmjs.com/package/@rtorcato/repo-tooling)
+
+## Description
+
+Your project description here.
+
+## Installation
+
+\`\`\`bash
+# Using pnpm (recommended)
+pnpm install
+
+# Using npm
+npm install
+
+# Using yarn
+yarn install
+\`\`\`
+
+## Development
+
+${generateDevelopmentSection(config)}
+
+## Testing
+
+${generateTestingSection(config)}
+
+## Building
+
+${generateBuildingSection(config)}
+
+## Scripts
+
+${generateScriptsSection(config)}
+
+## Project Structure
+
+\`\`\`
+${config.projectName}/
+├── src/                 # Source code
+${config.typescript.enabled ? '├── reset.d.ts           # TypeScript reset types' : ''}
+${config.testing.framework !== 'none' ? '├── tests/              # Test files' : ''}
+├── dist/               # Build output${config.projectType === 'library' ? ' (library)' : ''}
+├── package.json
+${config.typescript.enabled ? '├── tsconfig.json        # TypeScript configuration' : ''}
+${config.linting.tool === 'biome' || config.linting.tool === 'both' ? '├── biome.jsonc          # Biome configuration' : ''}
+${config.linting.tool === 'eslint' || config.linting.tool === 'both' ? '├── eslint.config.mjs    # ESLint configuration' : ''}
+${config.linting.tool === 'eslint' ? '├── prettier.config.mjs  # Prettier configuration' : ''}
+${config.testing.framework === 'vitest' ? '├── vitest.config.ts     # Vitest configuration' : ''}
+${config.testing.framework === 'jest' ? '├── jest.config.mjs     # Jest configuration' : ''}
+${config.testing.framework === 'playwright' ? '├── playwright.config.ts # Playwright configuration' : ''}
+${config.testing.framework === 'cypress' ? '├── cypress.config.ts   # Cypress configuration' : ''}
+${config.bundler === 'tsup' ? '├── tsup.config.ts       # tsup configuration' : ''}
+${config.bundler === 'esbuild' ? '├── build.mjs           # esbuild configuration' : ''}
+${config.bundler === 'rollup' ? '├── rollup.config.mjs   # Rollup configuration' : ''}
+${config.bundler === 'rolldown' ? '├── rolldown.config.mjs # Rolldown configuration' : ''}
+${config.bundler === 'vite' ? '├── vite.config.ts       # Vite configuration' : ''}
+${config.commitLint ? '├── commitlint.config.mjs # Commitlint configuration' : ''}
+${config.gitHooks ? '├── .husky/             # Git hooks' : ''}
+└── README.md
+\`\`\`
+
+## Tooling
+
+This project uses:
+
+${generateToolingList(config)}
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (\`git checkout -b feature/amazing-feature\`)
+3. Commit your changes (\`git commit -m 'feat: add amazing feature'\`)
+4. Push to the branch (\`git push origin feature/amazing-feature\`)
+5. Open a Pull Request
+
+${config.commitLint
+        ? `
+### Commit Convention
+
+This project follows [Conventional Commits](https://conventionalcommits.org/):
+
+- \`feat:\` new features
+- \`fix:\` bug fixes
+- \`docs:\` documentation changes
+- \`style:\` formatting changes
+- \`refactor:\` code refactoring
+- \`test:\` adding or updating tests
+- \`chore:\` maintenance tasks
+
+Run \`pnpm commit\` for a guided prompt (commitizen) that builds a compliant
+message; commitlint enforces the same rules on every commit.
+`
+        : ''}
+
+## License
+
+[Add your license here]
+`;
+    await fs.writeFile(readmePath, readme);
+}
+/**
+ * Build the badge block for a generated README. URLs are derived from the
+ * target's package.json (name + repository); visibility falls back to the
+ * project type (libraries are public, apps private) when `private` is unset.
+ */
+export async function buildReadmeBadgeBlock(config, targetDir) {
+    let repository;
+    let isPrivate = config.projectType !== 'library';
+    const pkgPath = path.join(targetDir, 'package.json');
+    if (await fs.pathExists(pkgPath)) {
+        const pkg = (await fs.readJson(pkgPath));
+        repository = pkg.repository;
+        if (typeof pkg.private === 'boolean')
+            isPrivate = pkg.private;
+    }
+    const parsed = parseRepository(repository);
+    return buildBadgeBlock({
+        name: config.projectName,
+        owner: parsed?.owner,
+        repo: parsed?.repo,
+        isPrivate,
+    });
+}
+function generateDevelopmentSection(config) {
+    const sections = [];
+    if (config.bundler === 'vite') {
+        sections.push('```bash\npnpm dev\n```');
+    }
+    else {
+        sections.push('Start development by running your preferred development server.');
+    }
+    if (config.linting.tool !== 'none') {
+        const lintCommand = config.linting.tool === 'biome' || config.linting.tool === 'both'
+            ? 'pnpm check:fix'
+            : 'pnpm lint:fix';
+        sections.push(`\n### Linting & Formatting\n\n\`\`\`bash\n${lintCommand}\n\`\`\``);
+    }
+    if (config.typescript.enabled) {
+        sections.push('\n### Type Checking\n\n```bash\npnpm typecheck\n```');
+    }
+    return sections.length > 0 ? sections.join('\n') : 'No specific development commands configured.';
+}
+function generateTestingSection(config) {
+    if (config.testing.framework === 'none') {
+        return 'No testing framework configured.';
+    }
+    const commands = [];
+    if (config.testing.framework === 'vitest') {
+        commands.push('pnpm test          # Run tests');
+        commands.push('pnpm test:watch    # Run tests in watch mode');
+        commands.push('pnpm test:ui       # Run tests with UI');
+        commands.push('pnpm coverage      # Generate coverage report');
+    }
+    else if (config.testing.framework === 'jest') {
+        commands.push('pnpm test          # Run tests');
+        commands.push('pnpm test:watch    # Run tests in watch mode');
+        commands.push('pnpm coverage      # Generate coverage report');
+    }
+    else if (config.testing.framework === 'playwright') {
+        commands.push('pnpm test:e2e      # Run E2E tests');
+        commands.push('pnpm test:e2e:ui   # Run E2E tests with UI');
+    }
+    else if (config.testing.framework === 'cypress') {
+        commands.push('pnpm test:e2e      # Run E2E tests (headless)');
+        commands.push('pnpm test:e2e:ui   # Open the Cypress runner');
+    }
+    return `\`\`\`bash\n${commands.join('\n')}\n\`\`\``;
+}
+function generateBuildingSection(config) {
+    if (config.bundler === 'none') {
+        return 'No build configuration set up.';
+    }
+    return '```bash\npnpm build\n```';
+}
+function generateScriptsSection(config) {
+    const scripts = [];
+    scripts.push('- `pnpm install` - Install dependencies');
+    if (config.typescript.enabled) {
+        scripts.push('- `pnpm typecheck` - Type check TypeScript');
+    }
+    if (config.linting.tool !== 'none') {
+        if (config.linting.tool === 'biome' || config.linting.tool === 'both') {
+            scripts.push('- `pnpm lint` - Lint code with Biome');
+            scripts.push('- `pnpm format` - Format code with Biome');
+            scripts.push('- `pnpm check:fix` - Lint and format with Biome');
+        }
+        if (config.linting.tool === 'eslint' || config.linting.tool === 'both') {
+            scripts.push('- `pnpm lint` - Lint code with ESLint');
+            scripts.push('- `pnpm lint:fix` - Fix ESLint issues');
+            scripts.push('- `pnpm format` - Format code with Prettier');
+        }
+    }
+    if (config.testing.framework !== 'none') {
+        scripts.push('- `pnpm test` - Run tests');
+        if (config.testing.framework === 'vitest') {
+            scripts.push('- `pnpm test:watch` - Run tests in watch mode');
+            scripts.push('- `pnpm coverage` - Generate test coverage');
+        }
+    }
+    if (config.bundler !== 'none') {
+        scripts.push('- `pnpm build` - Build for production');
+    }
+    if (config.commitLint) {
+        scripts.push('- `pnpm commit` - Write a conventional commit via a guided prompt');
+    }
+    return scripts.join('\n');
+}
+function generateToolingList(config) {
+    const tools = [];
+    if (config.typescript.enabled) {
+        tools.push('- **TypeScript** - Type-safe JavaScript');
+    }
+    if (config.linting.tool === 'biome') {
+        tools.push('- **Biome** - Fast formatter and linter');
+    }
+    else if (config.linting.tool === 'eslint') {
+        tools.push('- **ESLint** - Linting utility');
+        tools.push('- **Prettier** - Code formatter');
+    }
+    else if (config.linting.tool === 'both') {
+        tools.push('- **Biome** - Fast formatter and linter');
+        tools.push('- **ESLint** - Additional linting rules');
+    }
+    if (config.testing.framework === 'vitest') {
+        tools.push('- **Vitest** - Fast testing framework');
+    }
+    else if (config.testing.framework === 'jest') {
+        tools.push('- **Jest** - Testing framework');
+    }
+    else if (config.testing.framework === 'playwright') {
+        tools.push('- **Playwright** - End-to-end testing');
+    }
+    else if (config.testing.framework === 'cypress') {
+        tools.push('- **Cypress** - End-to-end testing');
+    }
+    if (config.bundler === 'tsup') {
+        tools.push('- **tsup** - TypeScript bundler');
+    }
+    else if (config.bundler === 'esbuild') {
+        tools.push('- **esbuild** - Fast JavaScript bundler');
+    }
+    else if (config.bundler === 'vite') {
+        tools.push('- **Vite** - Fast build tool');
+    }
+    if (config.gitHooks) {
+        tools.push('- **Husky** - Git hooks');
+        tools.push('- **lint-staged** - Run linters on staged files');
+    }
+    if (config.commitLint) {
+        tools.push('- **Commitlint** - Conventional commit linting');
+    }
+    if (config.semanticRelease) {
+        tools.push('- **Semantic Release** - Automated versioning and publishing');
+    }
+    if (config.releasePlease) {
+        tools.push('- **Release Please** - Automated release PRs and changelogs');
+    }
+    return tools.join('\n');
+}

package/dist/cli/generators/security.js

@@ -0,0 +1,156 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { renderCodeQLWorkflow } from '../../base/ci.js';
+import { LANGUAGES } from '../../languages/registry.js';
+/**
+ * The canonical dependency-update standard shared by every @rtorcato repo.
+ *
+ * `ecosystem` is the language's Dependabot `package-ecosystem` (#303) — null
+ * for a language Dependabot doesn't support, which drops the manifest block and
+ * leaves only the github-actions one.
+ */
+export function dependabotConfig(ecosystem) {
+    const manifest = ecosystem === null
+        ? ''
+        : `  - package-ecosystem: ${ecosystem}
+    directory: /
+    schedule:
+      interval: monthly
+      time: "06:00"
+      timezone: Etc/UTC
+    # Let brand-new releases settle before opening a PR — keeps grouped bumps
+    # from tripping pnpm's minimumReleaseAge supply-chain check (a same-day
+    # release fails the frozen-lockfile install in CI).
+    cooldown:
+      default-days: 7
+    open-pull-requests-limit: 5
+    versioning-strategy: increase
+    commit-message:
+      prefix: chore
+      include: scope
+    groups:
+      # Safe tier: runtime + dev minor/patch auto-merge on green (see the
+      # dependabot-automerge workflow). Grouped so react/react-dom move together.
+      production-minor:
+        dependency-type: production
+        update-types:
+          - minor
+          - patch
+      dev-minor:
+        dependency-type: development
+        update-types:
+          - minor
+          - patch
+      # Majors batch into one PR per ecosystem — breaking by definition, so
+      # never auto-merged; triaged on the monthly cadence.
+      major-updates:
+        update-types:
+          - major
+
+`;
+    return `version: 2
+updates:
+${manifest}  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: monthly
+    commit-message:
+      prefix: ci
+      include: scope
+`;
+}
+/** The JS flavour — the historical default, kept for the generators that don't
+ * resolve a language module. */
+export const DEPENDABOT_CONFIG = dependabotConfig('npm');
+/**
+ * Auto-merges patch + minor Dependabot PRs once CI is green. Requires branch
+ * protection with required status checks on the target branch — without it,
+ * \`gh pr merge --auto\` never fires. Majors are excluded (they land in the
+ * major-updates group for manual triage).
+ */
+export const DEPENDABOT_AUTOMERGE_WORKFLOW = `name: Dependabot auto-merge
+
+on: pull_request
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  auto-merge:
+    runs-on: ubuntu-latest
+    if: github.actor == 'dependabot[bot]'
+    steps:
+      - name: Fetch Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v3
+        with:
+          github-token: \${{ secrets.GITHUB_TOKEN }}
+
+      - name: Auto-merge patch and minor updates
+        if: |
+          steps.metadata.outputs.update-type == 'version-update:semver-patch' ||
+          steps.metadata.outputs.update-type == 'version-update:semver-minor'
+        run: gh pr merge --auto --squash "$PR_URL"
+        env:
+          PR_URL: \${{ github.event.pull_request.html_url }}
+          GH_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+`;
+/** Relative paths this generator owns, in a stable order for \`filesWritten\`. */
+export const DEPENDABOT_FILES = [
+    '.github/dependabot.yml',
+    '.github/workflows/dependabot-automerge.yml',
+];
+/**
+ * Scaffold the canonical Dependabot setup: the grouped \`dependabot.yml\` **and**
+ * the auto-merge workflow. They're a paired unit — the config batches updates
+ * into a safe tier and a major tier, and the workflow merges the safe tier on
+ * green. See \`apps/docs/docs/guides/dependabot-strategy.md\`.
+ */
+export async function generateDependabotConfig(targetDir, ecosystem = 'npm') {
+    await fs.ensureDir(path.join(targetDir, '.github', 'workflows'));
+    await fs.writeFile(path.join(targetDir, '.github', 'dependabot.yml'), dependabotConfig(ecosystem));
+    await fs.writeFile(path.join(targetDir, '.github', 'workflows', 'dependabot-automerge.yml'), DEPENDABOT_AUTOMERGE_WORKFLOW);
+    return [...DEPENDABOT_FILES];
+}
+export async function generateRenovateConfig(targetDir) {
+    const filepath = path.join(targetDir, 'renovate.json');
+    const content = `${JSON.stringify({
+        $schema: 'https://docs.renovatebot.com/renovate-schema.json',
+        extends: ['config:recommended', ':semanticCommits', ':semanticCommitTypeAll(chore)'],
+        schedule: ['before 4am on Monday'],
+        prConcurrentLimit: 10,
+        prHourlyLimit: 0,
+        rangeStrategy: 'bump',
+        packageRules: [
+            {
+                matchManagers: ['github-actions'],
+                commitMessagePrefix: 'chore(ci):',
+            },
+            {
+                matchManagers: ['npm'],
+                commitMessagePrefix: 'chore(deps):',
+            },
+        ],
+    }, null, 2)}\n`;
+    await fs.writeFile(filepath, content);
+}
+/**
+ * Scaffold `.github/workflows/codeql.yml` for the given CodeQL languages,
+ * defaulting to the JS module's matrix (#283).
+ *
+ * Returns the files written — empty when the language has no CodeQL support at
+ * all (Perl), since a workflow with an empty matrix would fail every run.
+ */
+export async function generateCodeQLWorkflow(targetDir, languages = LANGUAGES.js.codeqlLanguages) {
+    if (languages.length === 0)
+        return [];
+    await fs.ensureDir(path.join(targetDir, '.github', 'workflows'));
+    const filepath = path.join(targetDir, '.github', 'workflows', 'codeql.yml');
+    await fs.writeFile(filepath, renderCodeQLWorkflow(languages));
+    return ['.github/workflows/codeql.yml'];
+}
+export async function generateSecurityConfigs(targetDir) {
+    await generateDependabotConfig(targetDir);
+    await generateCodeQLWorkflow(targetDir);
+}

package/dist/cli/generators/skills-install.js

@@ -0,0 +1,70 @@
+// Documents the one-command `npx skills add` install for every agent skill a
+// repo ships under `skills/<name>/SKILL.md`. All values are derived from the
+// repo (its skills dir + package.json `repository`) so it works for any consumer.
+import path from 'node:path';
+import fs from 'fs-extra';
+import { upsertBlock } from './agent-rules.js';
+import { parseRepository } from './badges.js';
+export const SKILLS_DOCS_START = '<!-- js-tooling:skills:start -->';
+export const SKILLS_DOCS_END = '<!-- js-tooling:skills:end -->';
+/** Names of `skills/<name>/` directories that actually contain a SKILL.md. */
+export async function findSkills(targetDir) {
+    const skillsDir = path.join(targetDir, 'skills');
+    if (!(await fs.pathExists(skillsDir)))
+        return [];
+    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    const names = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (await fs.pathExists(path.join(skillsDir, entry.name, 'SKILL.md')))
+            names.push(entry.name);
+    }
+    return names.sort();
+}
+/**
+ * Build the README section body (inner content, no delimiters) listing one
+ * `npx skills add` command per skill. Returns '' when there are no skills.
+ */
+export function buildSkillsInstallBody(owner, repo, skills) {
+    if (skills.length === 0)
+        return '';
+    const commands = skills
+        .map((s) => `npx skills add https://github.com/${owner}/${repo} --skill ${s}`)
+        .join('\n');
+    const plural = skills.length > 1 ? 's' : '';
+    return [
+        `## Install the skill${plural} (\`npx skills\`)`,
+        '',
+        `Any agent that supports the [\`skills\`](https://www.npmjs.com/package/skills) CLI can install this repo's skill${plural} straight from GitHub — no clone, no package install:`,
+        '',
+        '```bash',
+        commands,
+        '```',
+    ].join('\n');
+}
+/**
+ * Add or refresh a "Install the skill" block in README.md. No-op (returns null)
+ * when the repo ships no skills or package.json has no GitHub `repository` to
+ * build the URL from. Merge-safe: only the delimited block is touched.
+ */
+export async function installSkillsInstallDocs(targetDir) {
+    const skills = await findSkills(targetDir);
+    if (skills.length === 0)
+        return null;
+    const pkgPath = path.join(targetDir, 'package.json');
+    const pkg = (await fs.pathExists(pkgPath))
+        ? (await fs.readJson(pkgPath).catch(() => null))
+        : null;
+    const parsed = parseRepository(pkg?.repository);
+    if (!parsed)
+        return null;
+    const body = buildSkillsInstallBody(parsed.owner, parsed.repo, skills);
+    if (!body)
+        return null;
+    await upsertBlock(path.join(targetDir, 'README.md'), body, {
+        start: SKILLS_DOCS_START,
+        end: SKILLS_DOCS_END,
+    });
+    return 'README.md';
+}

package/dist/cli/generators/tailwind.js

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+/**
+ * Scaffold Tailwind CSS v4. v4 is CSS-first — there is no `tailwind.config.js`
+ * and content is auto-detected, so the whole setup is a PostCSS plugin plus a
+ * CSS entry that imports Tailwind. Works uniformly for Vite, Next.js, and any
+ * PostCSS-based pipeline. Both files are safe-add — an existing file is never
+ * clobbered — so this can also repair a half-wired setup.
+ */
+export async function generateTailwind(targetDir) {
+    const written = [];
+    const postcss = path.join(targetDir, 'postcss.config.mjs');
+    if (!(await fs.pathExists(postcss))) {
+        await fs.writeFile(postcss, POSTCSS_CONFIG);
+        written.push('postcss.config.mjs');
+    }
+    const cssRel = path.join('src', 'styles', 'globals.css');
+    const css = path.join(targetDir, cssRel);
+    if (!(await fs.pathExists(css))) {
+        await fs.ensureDir(path.dirname(css));
+        await fs.writeFile(css, GLOBALS_CSS);
+        written.push(cssRel);
+    }
+    return written;
+}
+const POSTCSS_CONFIG = `export default {
+	plugins: {
+		'@tailwindcss/postcss': {},
+	},
+}
+`;
+// v4 config lives in CSS. Import `src/styles/globals.css` from your app entry.
+const GLOBALS_CSS = `@import "tailwindcss";
+`;

package/dist/cli/generators/testing.js

@@ -0,0 +1,88 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+export async function generateTestingConfigs(config, targetDir) {
+    if (config.testing.framework === 'vitest') {
+        await generateVitestConfig(config, targetDir);
+    }
+    else if (config.testing.framework === 'jest') {
+        await generateJestConfig(config, targetDir);
+    }
+    else if (config.testing.framework === 'playwright') {
+        await generatePlaywrightConfig(targetDir);
+    }
+    else if (config.testing.framework === 'cypress') {
+        await generateCypressConfig(targetDir);
+    }
+}
+export async function generateVitestConfig(config, targetDir) {
+    const vitestConfigPath = path.join(targetDir, 'vitest.config.ts');
+    const vitestConfig = `import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: '${config.testing.environment === 'browser' ? 'jsdom' : 'node'}',
+    setupFiles: ['./vitest.setup.ts'],
+    coverage: {
+      provider: 'v8',
+      // lcov feeds Codecov; text is the local console summary.
+      reporter: ['text', 'lcov']
+    }
+  }
+})
+`;
+    await fs.writeFile(vitestConfigPath, vitestConfig);
+    // Create setup file
+    const setupPath = path.join(targetDir, 'vitest.setup.ts');
+    const setupContent = `// Vitest setup file
+// Add global test setup here
+`;
+    await fs.writeFile(setupPath, setupContent);
+}
+async function generateJestConfig(config, targetDir) {
+    const jestConfigPath = path.join(targetDir, 'jest.config.mjs');
+    const environment = config.testing.environment === 'browser' ? 'browser' : 'node';
+    const jestConfig = `export { default } from '@rtorcato/repo-tooling/jest-presets/${environment}/jest-preset'
+`;
+    await fs.writeFile(jestConfigPath, jestConfig);
+}
+export async function generatePlaywrightConfig(targetDir) {
+    const playwrightConfigPath = path.join(targetDir, 'playwright.config.ts');
+    const playwrightConfig = `export { default } from '@rtorcato/repo-tooling/playwright'
+`;
+    await fs.writeFile(playwrightConfigPath, playwrightConfig);
+}
+const CYPRESS_EXAMPLE_SPEC = `describe('example', () => {
+  it('loads the app', () => {
+    cy.visit('/')
+  })
+})
+`;
+/**
+ * Scaffolds cypress.config.ts (a re-export of the shipped preset) plus the
+ * tests/e2e + cypress/support boilerplate. The config re-export is regenerated
+ * every run (idempotent); boilerplate/specs are only created when absent, so
+ * real tests are never clobbered. Returns the relative paths written.
+ */
+export async function generateCypressConfig(targetDir) {
+    const written = [];
+    await fs.writeFile(path.join(targetDir, 'cypress.config.ts'), `export { default } from '@rtorcato/repo-tooling/cypress'\n`);
+    written.push('cypress.config.ts');
+    const boilerplate = [
+        ['cypress/support/e2e.ts', `import './commands'\n`],
+        [
+            'cypress/support/commands.ts',
+            `// Add custom commands via Cypress.Commands.add(...).\nexport {}\n`,
+        ],
+        ['tests/e2e/example.cy.ts', CYPRESS_EXAMPLE_SPEC],
+    ];
+    for (const [rel, content] of boilerplate) {
+        const filePath = path.join(targetDir, rel);
+        if (await fs.pathExists(filePath))
+            continue;
+        await fs.ensureDir(path.dirname(filePath));
+        await fs.writeFile(filePath, content);
+        written.push(rel);
+    }
+    return written;
+}