front-end development standards / style guide

This project is a comprehensive collection of frontend development best practices and standards. It provides guides for writing semantic HTML, efficient CSS, and functional JavaScript to improve overall web performance and accessibility. The repository establishes frameworks for modern CSS architecture, focusing on specificity management and the use of Flexbox and Grid for predictable layouts. It outlines patterns for functional JavaScript programming, emphasizing the use of pure functions and composition to reduce execution time and dependency bloat. The guidelines cover several core capabi

This project is a web accessibility checklist and inclusive design framework. It serves as a digital inclusion guide and audit tool for verifying that web content is perceivable, operable, and welcoming to a diverse global audience. The project provides a structured review process for WCAG compliance, focusing on auditing HTML structure, ARIA roles, keyboard navigation, and visual accessibility. It includes specific standards for reviewing language, typography, and color contrast to ensure inclusive content design. The framework covers broader capability areas including device compatibility

This project is a comprehensive set of architectural and coding standards for organizing and maintaining high-quality JavaScript applications. It provides a framework for JavaScript project best practices across the full software development lifecycle, establishing unified guidelines for project organization and development. The guidelines cover specific standards for REST API design, utilizing resource-oriented interfaces and standardized HTTP methods. It also includes a web accessibility standard focused on semantic HTML and automated audits, alongside a defined Git workflow standard for br

This project is a CSS architecture framework and style guide providing formal coding standards for CSS and Sass. It establishes a structured approach to naming conventions, property organization, and selector management to ensure consistency across large-scale projects. The framework focuses on decoupling visual styles from JavaScript behavior through specific naming prefixes and utilizes a block element modifier system for component naming. It defines strict guidelines for Sass usage, emphasizing the efficient application of variables and mixins to prevent bloated output and complex dependen

This project provides a comprehensive set of coding standards and style guidelines for JavaScript development. It covers fundamental language syntax, formatting conventions, and best practices for managing variables, functions, objects, and modern language features. The documentation serves as a reference for maintaining consistent code quality across projects. In addition to general language standards, the guide includes specific conventions for building and organizing user interface components. These guidelines address structural patterns, component lifecycle management, and stylistic rules

Bulletproof React is an architectural guide and project boilerplate designed to standardize the development of large-scale, maintainable frontend applications. It provides a set of structural principles and organizational strategies that enforce a strict separation of concerns, ensuring that codebases remain manageable as they grow in complexity over time. The project distinguishes itself by promoting a modular design that groups related logic, components, and services into dedicated feature folders. It utilizes a composition-based approach to build user interfaces and implements a dependency

Standard is a suite of static analysis tools for JavaScript, comprising a linter, formatter, and a predefined style guide. It functions as a static code analyzer that scans source code for style violations and potential errors without executing the program. The project provides an automatic code fixer that rewrites source code to resolve formatting issues and enforce syntax consistency. It implements a standardized set of rules for JavaScript formatting and syntax to ensure a uniform appearance across different projects. The system covers a wide range of static analysis capabilities, includi

This project is a JavaScript style guide and a set of coding standards designed to ensure codebase consistency. It provides a collection of best practices for writing maintainable and idiomatic code, focusing on variable naming, type checking, and execution context. The project serves as a static analysis guide, offering frameworks and guidelines for using linters and automated tools to identify bugs and verify code correctness before deployment. It establishes standards for formatting, syntax, and variable declarations to standardize code style across a project. The scope of the project cov

Idiomatic CSS is a CSS style guide and architecture standard designed to ensure the creation of consistent and maintainable styles. It provides a set of standardized rules and conventions for writing idiomatic CSS code, functioning as both a formatting specification and a general guide for style organization. The project focuses on CSS preprocessor best practices, specifically providing guidelines to manage nesting depth and selector specificity to avoid complex cascades. It further distinguishes itself through structured documentation patterns and component sectioning to improve the long-ter

Common configurations for building web apps at Shopify

This project provides a comprehensive set of coding standards and conventions designed to ensure uniform development patterns across JavaScript codebases. It functions as a configuration-driven framework for static analysis, establishing rules that govern syntax, structure, and stylistic requirements to prevent common programming errors and reduce technical debt. The guide distinguishes itself by mandating specific structural practices, such as the use of literal syntax for object and array creation and the enforcement of strict equality comparisons to avoid implicit type coercion. It also em

This project provides a comprehensive framework for standardizing CSS architecture and development practices in large-scale web applications. It establishes a structured approach to managing design patterns, ensuring that stylesheets remain maintainable, scalable, and consistent across complex codebases. The methodology centers on the use of block-element-modifier naming conventions to organize user interface components into independent, reusable units. By enforcing flat selector specificity and namespace-based scoping, the framework prevents naming collisions and unintended style overrides.

This project provides a comprehensive style guide and architectural framework for building maintainable, modular, and consistent components within the Vue.js ecosystem. It establishes a set of standardized rules for organizing user interface elements into self-contained units, ensuring that logic and styles remain isolated to prevent unintended side effects. The guide distinguishes itself by focusing on strict encapsulation and clear interface design. It promotes the use of namespace-based style scoping to prevent visual leakage and enforces predictable component inputs through descriptive na

The repository contains a curated collection of coding conventions, architectural patterns, and best practices designed for developing component-based web applications using Angular and TypeScript. It functions as an architecture manual establishing consistent patterns across development teams, covering application structure, component design, and code quality enforcement. The guidelines define domain-driven file organization and module encapsulation strategies that group project assets into bounded contexts with dedicated root facades to keep large codebases manageable and shorten import pat

CSS Guidelines is a comprehensive style guide and reference for writing maintainable, scalable, and modular CSS in large-scale web projects. It provides a set of professional standards for organizing stylesheets and implementing consistent naming patterns to improve long-term codebase health and reduce technical debt. The project centers on a strict methodology for scoping classes to create isolated and predictable components, preventing style leakage between independent parts of a user interface. It emphasizes a flat selector hierarchy to avoid specificity conflicts and encourages the separa

This project provides a methodology for organizing, scoping, and naming styles to ensure maintainable and scalable stylesheets in large web applications. It functions as a structured approach to managing component-based styles, preventing global namespace collisions and simplifying long-term codebase maintenance through a set of established design principles. The architecture relies on strict namespace-based encapsulation, where all class names are prefixed with unique component identifiers to ensure visual isolation between modules. It enforces a class-only selector strategy to avoid the mai