foggy | Generate OpenGraph images from a Figma design in one click | User Interface library

Finally got this working. In case anyone else is stuck on this, here's an explanation (apologies for the lack of brevity - probably this should be a blog post...).

To flesh out the use case a bit further, I'm using Uppy to allow users to upload files to an AWS S3 bucket. The way this works is that, when the user uploads a file, Uppy makes a call to my server where an AWS pre-signed URL is generated and passed back to the client. The client then uses that pre-signed URL to upload the file directly to the S3 bucket, bypassing the server, such that the file doesn't pass through the server at any point.

The problem I was attempting to solve was that files missing an extension ended up uploaded with the content / MIME type set as "application/octet", because it seems the browser, Uppy, and S3 all rely on the file extension to decide the file type (rather than parsing the so-called "magic bytes" of the file), and if the file extension is missing, AWS defaults to "application/octet". This causes issues when users attempt to open the file, as they are not handled correctly (i.e. a png file without an extension and with an "application/octet" content / MIME type opens a download dialog rather than being previewed, etc.). I also want to validate the MIME type / file type in cases even where the extension exists so that I can exclude certain types of files, and so the files get handled appropriately when they are later downloaded (where the MIME type will again be validated) if an incorrect file extension is used.

I use the "file-type" NPM module to determine the mimetype server side, and that's straight forward enough, but changing the file's content type / MIME type when generating the AWS pre-signed URL is not enough to fix the problem - it still gets uploaded as "application/octet". I wanted to use the same module client side so we get the exact same results on the client as on the server, and needed in any case to determine the MIME type and set it accordingly pre-upload but post-pre-signed URL. I had no idea how to do this (i.e. use "file-type" client side - the meat of my question).

I finally gave up on Webpack - nothing I tried worked. So I switched to Browserify, and the sample browser code at the "file-type" repository worked at once! So then I was left trying to figure out how to pass a function through Browserify to use in the client side code.

This proved impossible for me - I couldn't figure out how to pass the asynchronous IIFE through to my code. So instead, I moved my Uppy code into the code I pass to Browserify:

What does/could this Javascript notation { e => e } signify?

It isn't JavaScript notation (e.g., syntax) in that context.¹ The display of objects in a console is not JavaScript syntax, though it's often closely related to it. That {e => e} (and {e => t} later) is just Chrome's console's way of showing you a Map entry where the key is an object whose constructor function is e and whose value is an object whose constructor function is also e (or t for the { e => t } case).

You can see that here (in Chrome or others that use a similar display):

This is the correct way to use format strings in Python:

In your NewsCardMaterial.js You are exporting as default

I was able to solve the issue with the help of Stack

Chrome looks like what I expect.

Because you're forcing height:100% I would expect the image to force itself to the grid, which you did not specify a min-height for and defined by fraction units.

Mozilla is not retaining the aspect ratio of the images, and defaulting to stretch the images to match the closest grid line, somehow. I didn't test it in Mozilla.

Remove all the height:100% references and add this to your CSS:

this is probably not the fastest approach in terms of run time but it works

This should work. Let me know if you have any questions

Short answer:

1. You may not do this: *reinterpret_cast(&data[pos]) = until there has been an object of type T constructed at the pointed-to address. Which you can accomplish by placement new.

2. Even then, you might need to use std::launder as for C++17 and later, since you access the created object (of type T) through a pointer &data[pos] of type char*.

"Direct" reinterpret_cast is allowed only in some special cases, e.g., when T is std::byte, char, or unsigned char.

Before C++17 I would use the memcpy-based solution. Compiler will likely optimize away any unnecessary copies.