```js const FormDataObjectizer = require("form-data-objectizer") const formData = new FormData()
A library to create readable "multipart/form-data" streams. Can be used to submit forms and file uploads to other web applications.
Performant, flexible and extensible forms library for React Hooks
Encode FormData content into the multipart/form-data format
React Hook Form validation resolvers: Yup, Joi, Superstruct, Zod, Vest, Class Validator, io-ts, Nope, computed-types, TypeBox, arktype, Typanion, Effect-TS and VineJS
Powerful, type-safe forms for React.
Spec-compliant FormData implementation for Node.js
Web API compatible Form Data implementation
React Form Component
Middleware for handling `multipart/form-data`.
A library to create readable "multipart/form-data" streams. Can be used to submit forms and file uploads to other web applications.
🏁 Framework agnostic, high performance, subscription-based form state management
🏁 High performance subscription-based form state management for React
A higher order component decorator for forms using Redux and React
View docs [here](https://radix-ui.com/primitives/docs/components/form).
Create and modify PDF files with JavaScript
Utility functions for @rjsf/core
The ajv-8 based validator for @rjsf/core
A simple React component capable of building HTML forms out of a JSON schema.
Array Mutators for 🏁 Final Form
Mantine form management library
React Form Component
A component for rendering and editing arrays 🏁 React Final Form
Collection of useful helper functions when trying to determine module type (CommonJS or AMD) properties of an AST node.
Compose, decouple and manage domain logic and data persistence separately. Works particularly great for composing form objects!
ActiveModel-compliant form objects for rails app. Forms have data and behavior. Let them be the objects they want to be. Plus, get presentation- specific validation logic out of your models.
Harvixture is a tool that can be used to extract data, in the form of fixtures, from a Rails project. It is done by pointing the harvixture at a request_path and dumping fixtures for all "found" ActiveRecord objects.
This library performs diffs of CSV data, or any table-like source. Unlike a standard diff that compares line by line, and is sensitive to the ordering of records, CSV-Diff identifies common lines by key field(s), and then compares the contents of the fields in each line. Data may be supplied in the form of CSV files, or as an array of arrays. The diff process provides a fine level of control over what to diff, and can optionally ignore certain types of changes (e.g. changes in position). CSV-Diff is particularly well suited to data in parent-child format. Parent- child data does not lend itself well to standard text diffs, as small changes in the organisation of the tree at an upper level can lead to big movements in the position of descendant records. By instead matching records by key, CSV-Diff avoids this issue, while still being able to detect changes in sibling order. This gem implements the core diff algorithm, and handles the loading and diffing of CSV files (or Arrays of Arrays). It also supports converting data in XML format into tabular form, so that it can then be processed like any other CSV or table-like source. It returns a CSVDiff object containing the details of differences in object form. This is useful for projects that need diff capability, but want to handle the reporting or actioning of differences themselves. For a pre-built diff reporting capability, see the csv-diff-report gem, which provides a command-line tool for generating diff reports in HTML, Excel, or text formats.
Harvixture is a tool that can be used to extract data, in the form of fixtures, from a Rails project. It is done by pointing the harvixture at a request_path and dumping fixtures for all "found" ActiveRecord objects.
Journeta is a dirt simple peer discovery and message passing library for processes on the same LAN, requiring no advanced networking knowledge to use. Only core Ruby libraries are required, making the library fairly light. As all data is sent across the wire in YAML form, so any arbitrary Ruby object can be sent to peers, written in any language.
This gem is still under active development. Please contact me directly with any questions or suggestions. To start: r = RedcapAPI.new(token, url) # your institution has it's own url, and each project has it's own token r.get(optional record_id) # returns all records in JSON format or a specific record if specified r.get_fields # returns all fields for that instrument r.post(data) # this will either update an old record or create a new one. the data should be in form of array of hashes or as a hash (for one item). dates are accepted in Date class or in strftime('%F') format. for example data = {name: 'this is a test', field_2: Date.today} r.post(data) # creates a new object using the fields above. field names must match those in the existing project "{\"count\": 1}" --> indicates the object posted. to update an existing record: data = {record_id: 3, name: 'this is a test to update', field_2: Date.today} r.post(data) # this will update the record with record_id 3. if record_id 3 does not exist it will create an entry with that record id
== Rails 3.1 javascript - Util asset pack == Sets up a window.Util object which includes * Spinner, with methods to set spinner next to element or hide the spinner * AjaxForm, to ajax enable simple forms * jQuery ajaxError global handler, exception data during development and friendly message in production == Usage spinner (js version) window.Util.spinner.nextTo('#my_button'); window.Util.spinner.nextTo('#my_button', 3, 4); // selector, top offset, left offset window.Util.spinner.hide(); ajax form (coffee script version) jQuery -> new window.Util.AjaxForm '#my_form', -> log "my_form submit success callback" == Install Update the Gemfile in your rails project, add the following line gem 'javascript_util_asset_pack' Run the generator rails generate javascript_util_asset_pack does the following: * Copy spinner.gif to /app/assets/images * Update application.html.erb adding javascript create window.Rails.env variable * Update application.html.erb adding image_tag for spinner.gif * Update application.js adding util_pack == WARNING * 0.0.10 and 0.0.11 are bad versions, use 0.0.12 or above == Coming Soon * configuration object * text in ajaxError overrides * spinner id override == Resources * spinner.gif generated using http://www.ajaxload.info == License The Unlicense (aka: public domain) http://unlicense.org == Ruby Gems * https://rubygems.org/gems/javascript_util_asset_pack
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.
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.
The Nodeum API makes it easy to tap into the digital data mesh that runs across your organisation. Make requests to our API endpoints and we’ll give you everything you need to interconnect your business workflows with your storage. All production API requests are made to: http://nodeumhostname/api/ The current production version of the API is v1. **REST** The Nodeum API is a RESTful API. This means that the API is designed to allow you to get, create, update, & delete objects with the HTTP verbs GET, POST, PUT, PATCH, & DELETE. **JSON** The Nodeum API speaks exclusively in JSON. This means that you should always set the Content-Type header to application/json to ensure that your requests are properly accepted and processed by the API. **Authentication** All API calls require user-password authentication. **Cross-Origin Resource Sharing** The Nodeum API supports CORS for communicating from Javascript for these endpoints. You will need to specify an Origin URI when creating your application to allow for CORS to be whitelisted for your domain. **Pagination** Some endpoints such as File Listing return a potentially lengthy array of objects. In order to keep the response sizes manageable the API will take advantage of pagination. Pagination is a mechanism for returning a subset of the results for a request and allowing for subsequent requests to “page” through the rest of the results until the end is reached. Paginated endpoints follow a standard interface that accepts two query parameters, limit and offset, and return a payload that follows a standard form. These parameters names and their behavior are borrowed from SQL LIMIT and OFFSET keywords. **Versioning** The Nodeum API is constantly being worked on to add features, make improvements, and fix bugs. This means that you should expect changes to be introduced and documented. However, there are some changes or additions that are considered backwards-compatible and your applications should be flexible enough to handle them. These include: - Adding new endpoints to the API - Adding new attributes to the response of an existing endpoint - Changing the order of attributes of responses (JSON by definition is an object of unordered key/value pairs) **Filter parameters** When browsing a list of items, multiple filter parameters may be applied. Some operators can be added to the value as a prefix: - `=` value is equal. Default operator, may be omitted - `!=` value is different - `>` greater than - `>=` greater than or equal - `<` lower than - `>=` lower than or equal - `><` included in list, items should be separated by `|` - `!><` not included in list, items should be separated by `|` - `~` pattern matching, may include `%` (any characters) and `_` (one character) - `!~` pattern not matching, may include `%` (any characters) and `_` (one character)
Contentful API wrapper library exposing an ActiveRecord-like interface