Skip to content

Commit

Permalink
Drop rollup replacements where no longer used
Browse files Browse the repository at this point in the history
  • Loading branch information
@fabiancook
fabiancook committed Oct 15, 2024
1 parent 0388e6a commit 1d6dbc7
Show file tree
Hide file tree
Showing 3 changed files with 21 additions and 607 deletions.
293 changes: 8 additions & 285 deletions example/polyfill-rollup.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1756,25 +1756,13 @@ function getNavigation() {
return (navigation$1 = new Navigation());
}


const getStructuredClone = () => json;

async function getStructuredCloneModule() {
const { stringify, parse } = await Promise.resolve().then(function () { return json; });
return { stringify, parse };
}
function structuredCloneFallback() {
const stringify = JSON.stringify.bind(JSON), parse = JSON.parse.bind(JSON);
return {
stringify,
parse
};
}
function stringify$1(value) {
return getStructuredClone().stringify(value);
let _stringify = JSON.stringify.bind(JSON);
let _parse = JSON.parse.bind(JSON);
function stringify(value) {
return _stringify(value);
}
function parse$1(value) {
return getStructuredClone().parse(value);
function parse(value) {
return _parse(value);
}

const AppLocationCheckChange = Symbol.for("@virtualstate/navigation/location/checkChange");
Expand Down Expand Up @@ -2095,7 +2083,7 @@ function setHistoryState(navigation, history, entry, persist, limit) {
if (typeof sessionStorage === "undefined")
return;
try {
const raw = stringify$1(getSerializableState());
const raw = stringify(getSerializableState());
sessionStorage.setItem(entry.key, raw);
}
catch { }
Expand Down Expand Up @@ -2132,7 +2120,7 @@ function getHistoryState(history, entry) {
const raw = sessionStorage.getItem(entry.key);
if (!raw)
return undefined;
const state = parse$1(raw);
const state = parse(raw);
if (!isStateHistoryWithMeta(state))
return undefined;
return state[NavigationKey].state;
Expand Down Expand Up @@ -2686,268 +2674,3 @@ if (shouldApplyPolyfill(navigation)) {
console.error(error);
}
}

const VOID = -1;
const PRIMITIVE = 0;
const ARRAY = 1;
const OBJECT = 2;
const DATE = 3;
const REGEXP = 4;
const MAP = 5;
const SET = 6;
const ERROR = 7;
const BIGINT = 8;
// export const SYMBOL = 9;

const env = typeof self === 'object' ? self : globalThis;

const deserializer = ($, _) => {
const as = (out, index) => {
$.set(index, out);
return out;
};

const unpair = index => {
if ($.has(index))
return $.get(index);

const [type, value] = _[index];
switch (type) {
case PRIMITIVE:
case VOID:
return as(value, index);
case ARRAY: {
const arr = as([], index);
for (const index of value)
arr.push(unpair(index));
return arr;
}
case OBJECT: {
const object = as({}, index);
for (const [key, index] of value)
object[unpair(key)] = unpair(index);
return object;
}
case DATE:
return as(new Date(value), index);
case REGEXP: {
const {source, flags} = value;
return as(new RegExp(source, flags), index);
}
case MAP: {
const map = as(new Map, index);
for (const [key, index] of value)
map.set(unpair(key), unpair(index));
return map;
}
case SET: {
const set = as(new Set, index);
for (const index of value)
set.add(unpair(index));
return set;
}
case ERROR: {
const {name, message} = value;
return as(new env[name](message), index);
}
case BIGINT:
return as(BigInt(value), index);
case 'BigInt':
return as(Object(BigInt(value)), index);
}
return as(new env[type](value), index);
};

return unpair;
};

/**
* @typedef {Array<string,any>} Record a type representation
*/

/**
* Returns a deserialized value from a serialized array of Records.
* @param {Record[]} serialized a previously serialized value.
* @returns {any}
*/
const deserialize = serialized => deserializer(new Map, serialized)(0);

const EMPTY = '';

const {toString} = {};
const {keys} = Object;

const typeOf = value => {
const type = typeof value;
if (type !== 'object' || !value)
return [PRIMITIVE, type];

const asString = toString.call(value).slice(8, -1);
switch (asString) {
case 'Array':
return [ARRAY, EMPTY];
case 'Object':
return [OBJECT, EMPTY];
case 'Date':
return [DATE, EMPTY];
case 'RegExp':
return [REGEXP, EMPTY];
case 'Map':
return [MAP, EMPTY];
case 'Set':
return [SET, EMPTY];
}

if (asString.includes('Array'))
return [ARRAY, asString];

if (asString.includes('Error'))
return [ERROR, asString];

return [OBJECT, asString];
};

const shouldSkip = ([TYPE, type]) => (
TYPE === PRIMITIVE &&
(type === 'function' || type === 'symbol')
);

const serializer = (strict, json, $, _) => {

const as = (out, value) => {
const index = _.push(out) - 1;
$.set(value, index);
return index;
};

const pair = value => {
if ($.has(value))
return $.get(value);

let [TYPE, type] = typeOf(value);
switch (TYPE) {
case PRIMITIVE: {
let entry = value;
switch (type) {
case 'bigint':
TYPE = BIGINT;
entry = value.toString();
break;
case 'function':
case 'symbol':
if (strict)
throw new TypeError('unable to serialize ' + type);
entry = null;
break;
case 'undefined':
return as([VOID], value);
}
return as([TYPE, entry], value);
}
case ARRAY: {
if (type)
return as([type, [...value]], value);

const arr = [];
const index = as([TYPE, arr], value);
for (const entry of value)
arr.push(pair(entry));
return index;
}
case OBJECT: {
if (type) {
switch (type) {
case 'BigInt':
return as([type, value.toString()], value);
case 'Boolean':
case 'Number':
case 'String':
return as([type, value.valueOf()], value);
}
}

if (json && ('toJSON' in value))
return pair(value.toJSON());

const entries = [];
const index = as([TYPE, entries], value);
for (const key of keys(value)) {
if (strict || !shouldSkip(typeOf(value[key])))
entries.push([pair(key), pair(value[key])]);
}
return index;
}
case DATE:
return as([TYPE, value.toISOString()], value);
case REGEXP: {
const {source, flags} = value;
return as([TYPE, {source, flags}], value);
}
case MAP: {
const entries = [];
const index = as([TYPE, entries], value);
for (const [key, entry] of value) {
if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
entries.push([pair(key), pair(entry)]);
}
return index;
}
case SET: {
const entries = [];
const index = as([TYPE, entries], value);
for (const entry of value) {
if (strict || !shouldSkip(typeOf(entry)))
entries.push(pair(entry));
}
return index;
}
}

const {message} = value;
return as([TYPE, {name: type, message}], value);
};

return pair;
};

/**
* @typedef {Array<string,any>} Record a type representation
*/

/**
* Returns an array of serialized Records.
* @param {any} value a serializable value.
* @param {{lossy?: boolean}?} options an object with a `lossy` property that,
* if `true`, will not throw errors on incompatible types, and behave more
* like JSON stringify would behave. Symbol and Function will be discarded.
* @returns {Record[]}
*/
const serialize = (value, {json, lossy} = {}) => {
const _ = [];
return serializer(!(json || lossy), !!json, new Map, _)(value), _;
};

/*! (c) Andrea Giammarchi - ISC */

const {parse: $parse, stringify: $stringify} = JSON;
const options = {json: true, lossy: true};

/**
* Revive a previously stringified structured clone.
* @param {string} str previously stringified data as string.
* @returns {any} whatever was previously stringified as clone.
*/
const parse = str => deserialize($parse(str));

/**
* Represent a structured clone value as string.
* @param {any} any some clone-able value to stringify.
* @returns {string} the value stringified.
*/
const stringify = any => $stringify(serialize(any, options));

var json = /*#__PURE__*/Object.freeze({
__proto__: null,
parse: parse,
stringify: stringify
});
Loading

0 comments on commit 1d6dbc7

Please sign in to comment.