@jasonshimmy/vite-plugin-cer-app 0.1.0

package/.github/copilot-instructions.md

@@ -0,0 +1,130 @@
+---
+applyTo: '**'
+---
+
+You are an expert in TypeScript, JavaScript, HTML, CSS. Your task is to produce the most optimized and maintainable code, following best practices and adhering to the principles of clean code and robust architecture.
+
+## Objective
+
+- Create a Web Component Runtime solution that is not only functional but also adheres to the best practices in performance, security, and maintainability.
+- When implementing features, prioritize simplicity and clarity in the codebase.
+- When communicating with the user, you don't need to ask for permission before making cleanups or optimizations. Instead, focus on delivering a solution that is efficient and easy to understand.
+
+## Commands to Know
+
+- `npm run build`: Builds the project for production.
+- `npm run dev`: Starts the development server with hot-reloading.
+- `npm test`: Runs the test suite using Vitest.
+- `npm test:watch`: Runs the test suite using Vitest in development watch mode.
+- `npm run test:coverage`: Generates a code coverage report.
+
+## Code Style and Structure
+
+- ALL CODE MUST BE: lightweight, developer friendly, strongly typed, performant, and scalable.
+- Write concise, technical TypeScript code with accurate examples.
+- Use functional and declarative programming patterns; avoid classes.
+- Prefer iteration and modularization over code duplication.
+- Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).
+- Structure files: exported component, subcomponents, helpers, static content, types.
+- Use lowercase with dashes for directory names (e.g., `components/auth-wizard`).
+- Use kebab-case for file names (e.g., `auth-wizard.ts`).
+- Avoid using "this" keyword in functional components.
+- Prefer pure functions and avoid side effects.
+- Use immutable data structures where possible.
+- Use JSDoc comments for functions and components to improve IDE intellisense.
+
+## Markdown Documentation
+
+All documentation written in the docs directory should be:
+
+- In Markdown format
+- Structured with clear headings and subheadings
+- Include code examples where applicable
+- Use consistent terminology and phrasing
+- Be 100% accurate with the actual code implementation
+- Be easy to read and understand
+- Be concise and to the point
+- Use emojis for titles
+
+## Naming Conventions
+
+- Use lowercase with dashes for directories (e.g., components/auth-wizard).
+- Favor named exports for components.
+
+## TypeScript Usage
+
+- Use strict TypeScript for all code; prefer interfaces over types.
+- Avoid enums; use maps instead.
+- Use functional components with TypeScript interfaces.
+- Never use "any" type; always prefer strongly typed definitions.
+
+## Syntax and Formatting
+
+- Use the "function" keyword for pure functions.
+- Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements.
+
+## UI and Styling
+
+- Generate Custom Elements using our lib/index.ts for components and styling.
+- Implement responsive design; use a mobile-first approach.
+
+## Performance Optimization
+
+- Use TypeScript and JavaScript best practices to ensure high performance.
+- Always favor tree-shaking and code splitting.
+- Optimize images: use WebP format, include size data, implement lazy loading.
+
+## Security and Performance
+
+- Implement proper error handling, user input validation, and secure coding practices.
+- Follow performance optimization techniques, such as reducing load times and improving rendering efficiency.
+
+## Testing and Documentation
+
+- Write unit tests for components using Vitest.
+- Provide clear and concise comments for complex logic.
+- Use JSDoc comments for functions and components to improve IDE intellisense.
+
+## Error Handling and Validation
+
+- Prioritize error handling and edge cases:
+  - Use early returns for error conditions.
+  - Implement guard clauses to handle preconditions and invalid states early.
+  - Use custom error types for consistent error handling.
+
+## Key Conventions
+
+- NEVER GUESS OR ASSUME! Always make informed decisions based on available data in a project.
+- Always use strongly typed TypeScript.
+- Keep code lightweight and modular.
+- Do not use external dependencies.
+- Keep code performant.
+- Keep code secure.
+- Keep code developer friendly and easy to use.
+- Keep code easy to read and understand.
+- Keep code maintainable and scalable.
+- Always write tests for your code.
+- Always follow best practices in coding, security, and performance.
+- A change can only be considered complete when it meets all the above criteria and has been thoroughly tested and reviewed. THIS IS NON-NEGOTIABLE.
+
+## Methodology
+
+1. **System 2 Thinking**: Approach the problem with analytical rigor. Break down the requirements into smaller, manageable parts and thoroughly consider each step before implementation.
+2. **Tree of Thoughts**: Evaluate multiple possible solutions and their consequences. Use a structured approach to explore different paths and select the optimal one.
+3. **Iterative Refinement**: Before finalizing the code, consider improvements, edge cases, and optimizations. Iterate through potential enhancements to ensure the final solution is robust.
+
+## Process:
+
+1. **Deep Dive Analysis**: Begin by conducting a thorough analysis of the task at hand, considering the technical requirements and constraints.
+2. **Planning**: Develop a clear plan that outlines the architectural structure and flow of the solution, using <PLANNING> tags if necessary.
+3. **Implementation**: Implement the solution step-by-step, ensuring that each part adheres to the specified best practices.
+4. **Review and Optimize**: Perform a review of the code, looking for areas of potential optimization and improvement.
+5. **Finalization**: Finalize the code by ensuring it meets all requirements, is secure, and is performant.
+
+### Coding Environment
+
+The user asks questions about the following coding languages:
+
+- TypeScript
+- HTML
+- CSS

package/.github/workflows/publish.yml

@@ -0,0 +1,206 @@
+name: Publish to npm
+
+on:
+  push:
+    branches:
+      - main
+      - develop
+
+permissions:
+  contents: write
+
+concurrency:
+  group: release-${{ github.ref_name }}
+  cancel-in-progress: false
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: 'true'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Fetch all history and tags
+
+      # Resolve the latest tag once so all subsequent steps share the same baseline.
+      - name: Resolve baseline tag
+        id: base
+        run: |
+          LATEST_TAG=$(git tag --sort=-version:refname | head -n1)
+          if [ -z "$LATEST_TAG" ]; then
+            COMMIT_RANGE="HEAD"
+          else
+            COMMIT_RANGE="${LATEST_TAG}..HEAD"
+          fi
+          echo "latest_tag=$LATEST_TAG" >> $GITHUB_OUTPUT
+          echo "commit_range=$COMMIT_RANGE" >> $GITHUB_OUTPUT
+          echo "Baseline tag: ${LATEST_TAG:-'(none - first release)'}"
+          echo "Commit range: $COMMIT_RANGE"
+
+      # Skip release if every commit since the last tag is chore: or docs:
+      # Breaking variants (chore!: / docs!:) are intentionally not excluded.
+      - name: Check if release is needed
+        id: should_release
+        run: |
+          COMMIT_RANGE="${{ steps.base.outputs.commit_range }}"
+          RELEASE_COMMITS=$(git log "$COMMIT_RANGE" --pretty=format:"%s" --no-merges \
+            | grep -vE "^(chore|docs)(\([^)]+\))?:" || true)
+          if [ -z "$RELEASE_COMMITS" ]; then
+            echo "value=false" >> $GITHUB_OUTPUT
+            echo "## Release skipped" >> $GITHUB_STEP_SUMMARY
+            echo "All commits since the last release use \`chore:\` or \`docs:\` prefixes — nothing to publish." >> $GITHUB_STEP_SUMMARY
+          else
+            echo "value=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Use Node.js version from .nvmrc
+        if: steps.should_release.outputs.value == 'true'
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: .nvmrc
+          registry-url: 'https://registry.npmjs.org/'
+
+      - name: Cache node modules
+        if: steps.should_release.outputs.value == 'true'
+        uses: actions/cache@v4
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-${{ hashFiles('package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Install dependencies
+        if: steps.should_release.outputs.value == 'true'
+        run: npm ci
+
+      - name: Run tests
+        if: steps.should_release.outputs.value == 'true'
+        run: npm test
+
+      - name: Build library
+        if: steps.should_release.outputs.value == 'true'
+        run: npm run build
+
+      - name: Configure Git
+        if: steps.should_release.outputs.value == 'true'
+        run: |
+          git config user.name "GitHub Actions"
+          git config user.email "actions@github.com"
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}
+
+      # Scan ALL commits since the last tag (not just HEAD) and handle the full
+      # conventional-commits spec: type(scope)!: and BREAKING CHANGE: in body.
+      - name: Determine version bump
+        id: bump
+        if: steps.should_release.outputs.value == 'true'
+        run: |
+          COMMIT_RANGE="${{ steps.base.outputs.commit_range }}"
+
+          SUBJECTS=$(git log "$COMMIT_RANGE" --pretty=format:"%s" --no-merges)
+          FULL_LOG=$(git log "$COMMIT_RANGE" --pretty=format:"%s%n%b" --no-merges)
+
+          BUMP="patch"
+
+          # Major: explicit BREAKING CHANGE footer OR ! after type/scope (e.g. feat!: / feat(scope)!:)
+          if echo "$FULL_LOG" | grep -qE "^BREAKING CHANGE:" || \
+             echo "$SUBJECTS" | grep -qE "^[a-z]+(\([^)]+\))?!:"; then
+            BUMP="major"
+          # Minor: feat: or feat(scope):
+          elif echo "$SUBJECTS" | grep -qE "^feat(\([^)]+\))?:"; then
+            BUMP="minor"
+          fi
+
+          echo "Bump type: $BUMP"
+          echo "bump=$BUMP" >> $GITHUB_OUTPUT
+
+      - name: Generate release notes
+        if: steps.should_release.outputs.value == 'true'
+        run: |
+          COMMIT_RANGE="${{ steps.base.outputs.commit_range }}"
+
+          COMMITS=$(git log "$COMMIT_RANGE" --pretty=format:"- %s (%h)" --no-merges \
+            | grep -vE "^- (release:|chore: update changelog)" || true)
+
+          if [ -z "$COMMITS" ]; then
+            COMMITS="- No changes since last release"
+          fi
+
+          echo "$COMMITS" > commits.txt
+
+      - name: Bump version
+        id: version
+        if: steps.should_release.outputs.value == 'true'
+        run: |
+          BUMP="${{ steps.bump.outputs.bump }}"
+          if [[ "${{ github.ref_name }}" == "develop" ]]; then
+            NEW_VERSION=$(npm version prerelease --preid=beta -m "release: %s [skip ci]")
+          else
+            NEW_VERSION=$(npm version "$BUMP" -m "release: %s [skip ci]")
+          fi
+          echo "version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          git push --follow-tags
+
+      - name: Create release and update changelog
+        if: steps.should_release.outputs.value == 'true'
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          PREV_TAG="${{ steps.base.outputs.latest_tag }}"
+          COMMITS=$(cat commits.txt)
+          DATE=$(date +"%Y-%m-%d")
+
+          if [ -n "$PREV_TAG" ]; then
+            CHANGELOG_LINK="**Full Changelog**: https://github.com/${{ github.repository }}/compare/${PREV_TAG}...${VERSION}"
+          else
+            CHANGELOG_LINK="**Full Changelog**: https://github.com/${{ github.repository }}/commits/${VERSION}"
+          fi
+
+          RELEASE_NOTES=$(printf '## Release %s\n\n### Changes\n%s\n\n%s' \
+            "$VERSION" "$COMMITS" "$CHANGELOG_LINK")
+
+          # Update or create CHANGELOG.md
+          if [ ! -f CHANGELOG.md ]; then
+            printf "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n" > CHANGELOG.md
+          fi
+
+          {
+            head -3 CHANGELOG.md
+            printf "## [%s] - %s\n\n%s\n\n" "$VERSION" "$DATE" "$COMMITS"
+            tail -n +4 CHANGELOG.md
+          } > CHANGELOG.tmp && mv CHANGELOG.tmp CHANGELOG.md
+
+          git add CHANGELOG.md
+          git commit -m "chore: update changelog for ${VERSION} [skip ci]" || true
+          git push
+
+          # Use python3 for safe multi-line JSON encoding (avoids sed escaping pitfalls)
+          ESCAPED_BODY=$(printf '%s' "$RELEASE_NOTES" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))")
+
+          if [[ "${{ github.ref_name }}" == "develop" ]]; then
+            PRERELEASE="true"
+            RELEASE_NAME="${VERSION} (Beta)"
+          else
+            PRERELEASE="false"
+            RELEASE_NAME="${VERSION}"
+          fi
+
+          curl -fsSL -X POST \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            https://api.github.com/repos/${{ github.repository }}/releases \
+            -d "{\"tag_name\":\"${VERSION}\",\"name\":\"${RELEASE_NAME}\",\"body\":${ESCAPED_BODY},\"prerelease\":${PRERELEASE}}"
+
+      - name: Publish to npm
+        if: steps.should_release.outputs.value == 'true'
+        run: |
+          if [[ "${{ github.ref_name }}" == "develop" ]]; then
+            npm publish --tag beta
+          else
+            npm publish
+          fi
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.nvmrc

@@ -0,0 +1 @@
+v22.18.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+## [v0.1.0] - 2026-03-18
+
+- fix: add nvmrc (7065201)
+- feat: add publishing capability (812152b)
+- initial commit (43a8365)
+
+