D

descarmendel

@descarmendel·40 public vizzes

Loading thumbnail…

Cars Report

This example displays a single line of text, "Toyota", extracted from a small hardcoded dataset of car records. It demonstrates a minimal React setup where a JSON array containing car make, model, year, and price is parsed and accessed. The page uses plain HTML with an inline script to select an element by ID and set its text content, while the accompanying `cars.js` module exports the parsed data for potential use in React components. No external visualization libraries are used.

Loading thumbnail…

Cars Report

This example displays a hardcoded array of car records with make, model, year, and price fields parsed from JSON. The page shows two text elements whose content is set via JavaScript, with one message updated through inline script and the other through an imported module. The visualization uses native DOM APIs like `document.getElementById` and `textContent` to modify the HTML, while the React framework handles component structure. The data remains static, with no interactive or graphical rendering beyond basic text updates.

Loading thumbnail…

Cars Report

This example displays a small dataset of five cars, showing their make, model, year, and price. The page updates two text elements with hardcoded messages, one using inline JavaScript in the HTML and the other via a React entry point that imports the car data from a separate module. The visualization uses `JSON.parse` on a string literal to form the data array, and demonstrates basic DOM text replacement through `document.getElementById` and `textContent`. No charts or graphical rendering are shown; it focuses on reactive text content.

Loading thumbnail…

Cars Report

This example displays a static “Cars Report” interface with two pre-formatted text elements, using React to import and parse a hardcoded JSON dataset of five used cars. The page initializes with placeholder text like “deeeee” and a clickable message, then updates the first element’s content via `document.getElementById` in JavaScript, while the second message is set by an inline script. It demonstrates basic DOM manipulation and data binding within a minimal HTML/CSS/JavaScript setup, relying on the `cars.js` module to supply structured car records without any visualization or interactive charts.

Loading thumbnail…

Cars Report

This example presents a simple cars report using static data defined in a `cars.js` module, which stores an array of car objects (make, model, year, price) parsed from a JSON string. The React-based project modifies text content on the page by directly manipulating the DOM via `document.getElementById`, setting messages into HTML `<pre>` elements. It also includes a plain JavaScript snippet that changes an element’s text on click. The visualization does not render charts or graphics, focusing instead on demonstrating basic DOM updates with no external libraries beyond React.

Loading thumbnail…

Cars Report

This example displays a simple cars report, showing the make of the first car in the dataset as text on the page. The code loads car data from a JSON string using `JSON.parse`, imports it into a React application, and uses `document.getElementById` to update text content. The page also includes a second paragraph with static text set via `textContent` in an inline script. The visualization relies on plain DOM manipulation and CSS styling for display.

Loading thumbnail…

Cars Report

This visualization presents a static report on a small dataset of used cars, displaying the make of the first car in the list. The page, built with React, imports car data from a local `cars.js` file and uses vanilla JavaScript to inject that value into an HTML `<pre>` element with the ID `message-element`. Another static message is set via an inline script in `index.html`. The example demonstrates basic data import and DOM manipulation without any charting or interaction.

Loading thumbnail…

Cars Report

This example displays a static text report of car data stored in the `cars.js` file. The code imports the parsed JSON array using an ES module and writes the price of the second car, `1800`, into the `message-element` using the DOM API `getElementById` and `textContent`. It also includes an inline script that overwrites the `m3` element with a greeting string. The page uses plain HTML, CSS, and JavaScript, with the React framework listed as metadata but not directly utilized in the visible behavior.

Loading thumbnail…

Cars Report

This example presents a small dataset of five used cars, each with its make, model, year, and price, imported from a JSON string in `cars.js`. The page displays a single car’s price inside a large `<pre>` element. The visualization, built with React and vanilla JavaScript, uses `document.getElementById` to inject the numeric value into the HTML container, while another script sets static text on a second element. It demonstrates basic DOM manipulation and JSON parsing without any charting library.

Loading thumbnail…

Cars Report

This example presents a small dataset of five cars, showing each vehicle’s make, model, year, and price as static JSON parsed into a JavaScript array. The visualization renders the price of the second car directly into a page element using React’s component model. The code uses the native `JSON.parse` method via an imported `cars` module and updates the DOM through `document.getElementById().textContent`. A second hardcoded message also replaces text in another element, demonstrating simple state changes without interactive charts or graphs.

Loading thumbnail…

Cars Report

This example shows a minimal React-based web page that imports car data from a local JavaScript file and displays the first car’s make (Toyota) as text in an HTML element. The code uses the `cars` array from `cars.js`, parsed via `JSON.parse`, and updates the page’s DOM with `document.getElementById().textContent`. The page also includes static text and a separate script that changes another element’s content. The visualization relies on vanilla JavaScript and HTML, with no external charting libraries.

Loading thumbnail…

Cars Report

This example displays a car report in a React-based visualization, showing the make of the first car in a dataset as text on a webpage. The data is stored in a JavaScript file as a JSON array containing attributes like year, make, model, and price, parsed with `JSON.parse`. The page uses plain HTML and JavaScript to render the message, with the `index.js` file importing the car data and updating a `<pre>` element’s text content via `document.getElementById`. The visualization relies on React and basic DOM manipulation rather than a specific charting library.

Loading thumbnail…

Cars Report

This example demonstrates a minimal interactive page titled “Cars Report” that displays static text elements in the browser. It renders two preformatted blocks with large font sizes, where one block’s content is updated by JavaScript in the HTML file, and the other is modified by code in an external `index.js` script. The page uses plain HTML with embedded CSS styling and vanilla JavaScript DOM manipulation via `document.getElementById` and `textContent`. It does not include any data visualization or external libraries, relying solely on React-free, framework-less client-side scripting.

Loading thumbnail…

Cars Report

This example displays a bare-bones HTML page that uses vanilla JavaScript to replace predefined text content within two `<pre>` elements. The page initially shows placeholder phrases like “kang kang.” and a clickable message prompt, but script tags immediately overwrite these strings with different “Hello World!!!!!!!” variants. The code also includes an `index.js` file that attempts to update a third element via `document.getElementByID`, though that call contains a capitalization error and targets an ID not present in the HTML. The visualization demonstrates basic DOM manipulation without any external libraries or data processing.

Loading thumbnail…

Cars Report

This example demonstrates basic DOM manipulation in a web page titled “Cars Report,” where two text elements are updated via JavaScript to display the string “HELLO WORLD.” Using the `getElementById` and `textContent` APIs, the code replaces the initial content of the `<pre>` elements when the page loads. The page relies on plain HTML, CSS for font sizing, and vanilla JavaScript, with no external libraries or data sources. A separate `index.js` file also attempts to update a non-existent element, showing a typical error-prone setup for a beginner React-free starter.

Loading thumbnail…

Cars Report

This example presents a simple web page titled "Cars Report" that displays two text elements labeled "kang kang" and "Click me to change my textual content." The page uses JavaScript to modify the text content of these elements, with one script setting the second element's text to "HELLO WORLD wow it's ok ~~~~" and another attempting to update the first. The code relies on the `document.getElementById` and `document.getElementByID` methods to access the HTML `<pre>` elements, though one call contains a typo. The page uses basic HTML and CSS styling with an inline font-size property.

Loading thumbnail…

Cars Report

This example displays a minimal web page titled “Cars Report” that initially shows placeholder text elements, including a large “kang kang” message and a clickable line prompting a content change. The page uses a JavaScript script to replace the clickable element’s text with “HELLO WORLD ~~~~”, while a second script attempts to update another element using `document.getElementByID`, though it incorrectly applies JavaScript’s `getElementById` method with an uppercase “ID”. The code relies on basic DOM manipulation via `textContent` within an HTML file, with no external libraries or data sources involved.

Loading thumbnail…

Cars Report

This example displays a pair of text elements on a webpage, initially showing “kang kang” and “Click me to change my textual content.” Upon loading, JavaScript within the HTML document’s inline script updates both elements’ textual content to “HELLO WORLD ~~~~” and “Hello World!!!!!!!,” respectively. The page uses DOM manipulation through `getElementById` and the `.textContent` property to perform these changes. A separate `index.js` file repeats one of these updates, though its call contains a capitalization error (`getElementByID`). The visualization is a simple demonstration of dynamic text modification using native JavaScript APIs.

Loading thumbnail…

Cars Report

This example displays a minimal interactive web page that presents plain text messages, primarily “HELLO WORLD” and “kang kang,” using HTML `<pre>` elements. The page relies on vanilla JavaScript to dynamically update the text content of one element when clicked, while another element receives a static string assignment. No external data source or visualization library is used; the rendering approach is pure DOM manipulation via `document.getElementById` and `textContent`. The code also includes commented-out `console.log` statements, suggesting debugging within browser developer tools.

Loading thumbnail…

Cars Report

This example shows a minimal HTML page that displays static text messages, including a hardcoded “HELLO WORLD ~~~~” and a separate element that initially reads “kang kang.” The page uses vanilla JavaScript in inline `<script>` tags and an external `index.js` file, both attempting to update the text content via `document.getElementById` (with a typo in the method name). The page relies on plain DOM manipulation, with no data source, visualization libraries, or rendering frameworks beyond basic HTML and CSS styling.

Loading thumbnail…

Cars Report

This example displays a minimal web page titled “Cars Report” that demonstrates basic DOM manipulation with JavaScript. Upon loading, the script replaces the initial text in a `<p>` element with “HELLO WORLD ~~~~” using `document.getElementById().textContent`. A second script attempts to update a `<pre>` element with a message but uses the misspelled method `getElementByID`, causing a runtime error that leaves the original “kang kang” text unchanged. The page also includes a commented-out `console.log` statement and references a React starter, though no React code is present.

Loading thumbnail…

Cars Report

This example shows a minimal interactive page titled “Cars Report” that displays static text elements, including a large “kang kang” message and a paragraph whose content changes to “Paragraph changed!” on load. The code uses plain JavaScript `document.getElementById` to update text content, with one attempt to modify the large message via an external `index.js` file. It also logs to the browser console, though the main rendering relies on basic HTML and CSS, not a data visualization framework or charting library.

Loading thumbnail…

Cars Report

This example presents a minimal interactive webpage that reads and displays a hardcoded text message. It uses plain HTML and JavaScript to show the text "kang kang" in a large `<pre>` element, while a separate paragraph toggles its content when clicked via an inline `onclick` handler. The code also attempts to update the message element using `document.getElementById`, though the helper function name is misspelled, so the initial text remains unchanged. No external libraries or data sources are used; the rendering relies solely on the browser’s DOM APIs.

Loading thumbnail…

CarReport

This example renders the current time as large text in a browser page. It uses the DOM API `document.getElementByID` to select the `pre` element with the id `message-element` and sets its text content to the string `"Hello World!!!!!!!"`. The code includes commented-out React imports and JSX, indicating a React starter template, but the active implementation relies solely on plain JavaScript DOM manipulation. The rendering approach is a simple static text assignment, with no data source or dynamic updates.

Loading thumbnail…

Cars Report

This example displays a simple web page titled “Cars Report” that greets the viewer with a large “Hello World!!!!!!!” message, dynamically inserted into a preformatted text element. Built with vanilla JavaScript and HTML, the page uses document.getElementByID to update the message element’s text content. The rendering relies on standard DOM APIs rather than a charting library, and the static greeting is the sole visible output, with no data or interactive features present.

Loading thumbnail…

Cars Report

This example displays a static HTML page titled “Cars Report” that renders a greeting message in a large `<pre>` element. The page uses plain JavaScript in both an inline script and an external `index.js` file to set the text content of an element by its ID via `document.getElementByID` (a misspelled variant of `getElementById`). The code demonstrates basic DOM manipulation and embedding JavaScript in HTML, but includes no charting or data visualization libraries. The rendering approach is minimal HTML with CSS styling via the `style` attribute, and no external data sources are referenced.

Loading thumbnail…

Cars Report

This example presents a minimal web page titled “Cars Report” that greets the viewer with a static message. Built with HTML, CSS, and JavaScript, the page uses a `<pre>` element to display text and a small script to update its content via `document.getElementByID`. The code, which also includes a commented-out `console.log` call, does not render any data or chart, instead serving as a bare-bones demonstration of DOM manipulation within a React starter context.

Loading thumbnail…

Cars Report

This example presents a minimal HTML page titled “Cars Report” that outputs a static “Hello World!!!!!!!” message. The page uses a `<pre>` element with the ID `message-element` to display the text, which is set via JavaScript’s `document.getElementByID()`. The code includes plain HTML, CSS, and JavaScript, but does not use any visualization libraries or data sources. The rendering approach is limited to basic DOM manipulation, with no charts, graphs, or interactive elements present.

Loading thumbnail…

Cars Report

This example shows a minimal "Cars Report" page that currently displays the text "Hello World!!!!!!!" in a `<pre>` element using plain JavaScript. The code runs entirely in the browser through `index.html`, which sets up the document structure and calls `document.getElementByID` to insert the message. It relies on vanilla JS and CSS without any external libraries or frameworks, despite the metadata mentioning React. The page serves as a barebones starter for future data visualization work, as it only renders static text and has no actual car data or charts.

Loading thumbnail…

Cars Report

This example displays a static "Hello World!!!!!!!" message in a web page, rendered from a JavaScript variable into a `<pre>` element. It demonstrates a minimal setup using React and CSS, with the core logic in `index.js` calling `document.getElementByID` to update the DOM. The page includes a `bundle.js` script reference, though the inline script also duplicates the message assignment. No data source or visualization library is used; the example focuses on basic HTML, CSS, and JavaScript integration within a React framework.

Loading thumbnail…

Cars Report

This example shows a minimal web page that displays the text “Hello World!!!!!!!” in a preformatted element. The page uses React as its framework, though the core behavior relies on plain JavaScript. The `index.js` file assigns a message string to the `textContent` property of an element with the ID `message-element`, which is found in the HTML structure. The page’s content is rendered in the browser, with the `bundle.js` script loading the JavaScript logic. The example demonstrates a basic setup for displaying static content in a React-based project.

Loading thumbnail…

Cars Report

This example renders a minimal “Cars Report” page that displays a static text message. The page uses a basic HTML structure with a `<pre>` element to show the text, and the behavior is implemented in JavaScript by directly setting the element’s text content. The code relies on React as the framework, though the core interaction is a simple `getElementById` call to update the DOM, with the message stored in a variable and printed on load. The visualization is static, with no data source or interactive rendering.

Loading thumbnail…

Cars Report

This example shows a minimal web page that displays a static text message, “Hello World!!!!!!!”, in a preformatted block. It uses plain HTML, CSS, and JavaScript to render the content, with the message set via `document.getElementByID("message-element").textContent`. The page has a title, “Cars Report”, but contains no data visualization or interactive behavior; it serves as a basic starter template for a React-based project.

Loading thumbnail…

Cars Report

This example displays a plain HTML page titled “Cars Report” that uses vanilla JavaScript to inject the text “Hello World!!!!!!!” into a `<pre>` element. The page defines a minimal DOM structure with a script tag pointing to an external `index.js` file. The JavaScript sets the `textContent` of the element with the ID `message-element` to the message string, though the code uses the misspelled `getElementByID` method instead of the correct `getElementById`. No data, visualization, or external libraries are included beyond basic HTML and CSS.

Loading thumbnail…

Cars Report

This example presents a minimal "Cars Report" web page that displays a static text message. The page is built with HTML, CSS, and JavaScript, using a simple `<pre>` element and a script tag. The JavaScript code, which runs via `index.js`, attempts to update the page’s content by setting the `textContent` of the element with the ID “message-element” to the string “Hello World!!!!!!!”, though a typo in the method name prevents it from working. The project is structured as a React-focused starter, but here it runs as a plain HTML document.

Loading thumbnail…

Cars Report

This example displays a static “Hello World!!!!!!!” message in a preformatted `<pre>` element on an HTML page. The code uses vanilla JavaScript with the `document.getElementByID` method to select the message element and set its text content via the `textContent` property. The page is minimal, containing only the HTML structure, a script tag, and a link to a React starter resource. It demonstrates basic DOM manipulation without any external data or visualization libraries.

Loading thumbnail…

Cars Report

This example displays a simple “Cars Report” page that outputs the text “Hello World!!!!!!!” onto the page. The page is built with a bare minimum HTML structure and uses JavaScript to set the content of a `<pre>` element. The code specifically uses `document.getElementByID` to target the element and assign the message via the `textContent` property. The JavaScript source is loaded from an external `index.js` file, with no additional libraries or data sources involved.

Loading thumbnail…

Cars Report

A minimal React starter page renders the static text “Hello World!!!!!!!” inside a preformatted HTML element. The single-page example uses plain JavaScript to select the element by ID and assign a text message, with no external data or visualization libraries. The code demonstrates basic DOM manipulation via `getElementByID` and serves as a bare-bones template for future interactive projects.

Loading thumbnail…

Cars Report

This example displays a minimal web page titled “Cars Report” that uses plain HTML, CSS, and JavaScript to render the text “Hello World!!!!!!!” inside a `<pre>` element. The code defines a constant `message` and assigns it to the element via `document.getElementByID`, though the method name is misspelled (it should be `getElementById`). No external libraries or frameworks are imported, and the page loads `index.js` as a script without any data source or visualization rendering.

Loading thumbnail…

HTML Starter

This example renders the text “Hello HTML” at a massive 13em font size, centered on the page with CSS. It demonstrates the minimal structure of an HTML document, combining a style block for presentation and a script block that logs “Hello JavaScript!” to the browser console. The page uses no external libraries, relying solely on core HTML, CSS, and JavaScript APIs to illustrate a basic static visualization setup. It serves as a starting point for embedding data-driven graphics.