Transform lodash imports to include into bundle only imported functions
Smart file filter for AI consumption - search and bundle only files containing specific strings
a watchify plugin, provides to re bundle only when files changed
A package that creates a dependency tree in a future webpack bundle only by package.json.
Convert various schema validation libraries to JSON Schema
Get bundle name from a bundle identifier (macOS): `com.apple.Safari` → `Safari`
A tiny, tree-shakeable ID toolkit for TypeScript apps. Secure core with optional subpath exports for prefixed IDs, typed IDs, validation, and custom alphabets.
vite-plugin-istanbul ==========================
Chart components for ENACT UI built on Recharts. Adds ~200KB to bundle. Only install if you need charts.
Webpack plugin and CLI utility that represents bundle content as convenient interactive zoomable treemap
Translates between file formats and generates static code as well as TypeScript definitions.
ECMAScript code generator
bundle and require a file
Throw, identify, and decode Solana JavaScript errors
OpenTelemetry instrumentation for AWS Lambda function invocations
A treeshaken subset of JSTS functions for use within
Experimental debugger shell for React Native for use with @react-native/debugger-frontend
Sigstore bundle type
A simple webpack plugin to support dotenv.
MSR JavaScript Cryptography Library
Lite version of json-schema-to-typescript
OpenTelemetry instrumentation for `lru-memoizer` function memoization using lru-cache
JupyterLab - Interfaces for Mime Renderers
A simpler (and smaller) rewrite of Google Android's libphonenumber library in javascript
A custom Bevy plugin for adding translations (i18n) with WASM support, plurals, gender, and reactive UI
ruLake — vector-native federation intermediary over heterogeneous backends (ADR-155)
Cargo subcommand for certification evidence generation, verification, and traceability
Certification evidence generation, verification, and traceability library for safety-critical Rust projects
This gem provides a bundle-only command that installs a set of gems listed in specified Gemfile group. Gems are always installed into the system and never update Gemfile.lock.
== Let's intuitively write API documentation with Swagger Editor in your Rails Project! 😊 Configureless and no DSL. 👍 But you can also configure. Manage with yaml file instead of Ruby code. Loosely coupled to your Rails project. 👍 So if you want to use another tool, you can port it right away. 😢 Generate api docment(OpenAPI) side only from `Rails` routing. Provide rake tasks to management API Docment (OpenAPI) 🎉 $ bundle exec rake routes:oas:init $ bundle exec rake routes:oas:docs $ bundle exec rake routes:oas:ui $ bundle exec rake routes:oas:editor $ bundle exec rake routes:oas:monitor $ bundle exec rake routes:oas:build $ bundle exec rake routes:oas:clean $ bundle exec rake routes:oas:analyze $ bundle exec rake routes:oas:deploy Happy Coding ❗️
An Invariable bundles a number of read-only attributes. It can be used like a Hash as well as an Array. It supports subclassing and pattern matching.
PostgreSQL has built-in full text search feature. But it supports only limited languages. For example, it doesn't support Japanese. pg_trgm bundled in PostgreSQL supports all languages including Japanese. But it has performance problems for large documents. This talk describes about PGroonga that resolves these problems.
Antoinette analyzes which Elm apps are used in Rails views, bundles them together, and injects script tags into templates. Minimizes HTTP requests while ensuring each page only loads the Elm apps it needs.
An alternative RubyGems loader that pulls in only the minimal components required at runtime, instead of the full RubyGems stack used during gem installation. Ideal for use with standalone bundles, allowing RubyGems to be disabled via --disable-gems while still providing essential runtime functionality.
# Rack::ReadOnly This gem allows Rack based APIs to be set to read only. At the most basic it can be used like this from your `config.ru`: ```ruby require 'rack/read_only' use Rack::ReadOnly, { active: ENV["READ_ONLY"] == "1", response_body: '{ "error": "This API is currently in read only mode." }' } run MyApp ``` When in read only mode the API will continue to respond to GET, HEAD, and OPTIONS requests as normal, but reject POST, PUT, DELETE, and PATCH requests with the body specified, and a 503 error code. ## Installation Add this line to your application's Gemfile: ```ruby gem 'rack-read_only' ``` And then execute: $ bundle Or install it yourself as: $ gem install rack-read_only ## Development After checking out the repo, run `bin/setup` to install dependencies. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing 1. Fork it ( https://github.com/jellybob/rack-read_only/fork ) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Add some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create a new Pull Request Any new builds should pass the tests on [Travis](https://travis-ci.org/jellybob/rack-read_only)
Distribute webhooks to multiple recipients
This fastlane plugin includes the following actions: 1) multi_scan: uses scan to run Xcode tests, optionally in batches, a given number of times: only re-testing failing tests. 2) suppress_tests_from_junit: uses a junit xml report file to suppress either passing or failing tests in an Xcode Scheme. 3) suppress_tests: suppresses specific tests in a specific or all Xcode Schemes in a given project. 4) suppressed_tests: retrieves a list of tests that are suppressed in a specific or all Xcode Schemes in a project. 5) tests_from_junit: retrieves the failing and passing tests as reported in a junit xml file. 6) tests_from_xctestrun: retrieves all of the tests from xctest bundles referenced by the xctestrun file 7) collate_junit_reports: collects and correctly organizes junit reports from multiple test passes.
This plugin uses esbuild to process the targeted JavaScript static files in a Jekyll site whenever the site is built. By default, it targets all static files with .js extension, but it can be configured to target only the files specified in a list, which also allows including files of other content types supported by esbuild, such as TypeScript or JSX (still untested with this plugin, however). There are also other options to toggle bundling, minification, and source maps.
RSence is a different and unique development model and software frameworks designed first-hand for real-time web applications. RSence consists of separate, but tigtly integrated data- and user interface frameworks. RSence could be classified as a thin server - thick client system. Applications and submobules are installed as indepenent plugin bundles into the plugins folder of a RSence environment, which in itself is a self-contained bundle. A big part of RSence itself is implemented as shared plugin bundles. The user interface framework of RSence is implemented in high-level user interface widget classes. The widget classes share a common foundation API and access the browser's native API's using an abstracted event- and element layer, which provides exceptional cross-browser compatibility. The data framework of RSence is a event-driven system, which synchronized shared values between the client and server. It's like a realtime bidirectional form-submission engine that handles data changes intelligently. On the client, changed values trigger events on user interface widgets. On the server, changed values trigger events on value responder methods of server plugin modules. It doesn't matter if the change originates on client or server, it's all synchronized and propagated automatically. The server framework is implemented as a high-level, modular data-event-driven system, which handles delegation of tasks impossible to implement using a client-only approach. Client sessions are selectively connected to other client sessions and legacy back-ends via the server by using the data framework. The client is written in Javascript and the server is written in Ruby. The client also supports CoffeeScript for custom logic. In many cases, no custom client logic is needed; the user interfaces can be defined in tree-like data models. By default, the models are parsed from YAML files, and other structured data formats are possible, including XML, JSON, databases or any custom logic capable of producing similar objects. The server can connect to custom environments and legacy backends accessible on the server, including software written in other languages.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.