@oxymoron.13/tizentube-s95b 0.2.2 → 0.3.0

package/mods/ui/ytUI.js

@@ -0,0 +1,510 @@
+import resolveCommand from '../resolveCommand.js';
+
+function showToast(title, subtitle, thumbnails) {
+    const toastCmd = {
+        openPopupAction: {
+            popupType: 'TOAST',
+            popup: {
+                overlayToastRenderer: {
+                    title: {
+                        simpleText: title
+                    },
+                    subtitle: {
+                        simpleText: subtitle
+                    }
+                }
+            }
+        }
+    }
+
+    if (thumbnails) {
+        toastCmd.openPopupAction.popup.overlayToastRenderer.image.thumbnails = thumbnails;
+    }
+    resolveCommand(toastCmd);
+}
+
+function OverlayPanelHeaderRenderer(title, subtitle, thumbnails) {
+    return {
+        overlayPanelHeaderRenderer: {
+            title: {
+                simpleText: title
+            },
+            subtitle: {
+                simpleText: subtitle
+            },
+            image: {
+                thumbnails: thumbnails
+            },
+            style: "OVERLAY_PANEL_HEADER_STYLE_VIDEO_THUMBNAIL"
+        }
+    }
+}
+
+function Modal(header, content, id, update) {
+    const titleSubtitleObj = typeof header === 'string' ? { title: header, subtitle: '' } : header;
+    const overlayPanelHeaderRenderer = header.overlayPanelHeaderRenderer || {
+        title: {
+            simpleText: titleSubtitleObj.title
+        }
+    };
+    const modalCmd = {
+        openPopupAction: {
+            popupType: 'MODAL',
+            popup: {
+                overlaySectionRenderer: {
+                    overlay: {
+                        overlayTwoPanelRenderer: {
+                            actionPanel: {
+                                overlayPanelRenderer: {
+                                    header: {
+                                        overlayPanelHeaderRenderer
+                                    },
+                                    content
+                                }
+                            },
+                            backButton: {
+                                buttonRenderer: {
+                                    accessibilityData: {
+                                        accessibilityData: {
+                                            label: 'Back'
+                                        }
+                                    },
+                                    command: {
+                                        signalAction: {
+                                            signal: 'POPUP_BACK'
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    dismissalCommand: {
+                        signalAction: {
+                            signal: 'POPUP_BACK'
+                        }
+                    }
+                }
+            },
+            uniqueId: id
+        }
+    }
+
+    if (titleSubtitleObj.subtitle) {
+        modalCmd.openPopupAction.popup.overlaySectionRenderer.overlay.overlayTwoPanelRenderer.actionPanel.overlayPanelRenderer.header.overlayPanelHeaderRenderer.subtitle = {
+            simpleText: titleSubtitleObj.subtitle
+        };
+    }
+
+    if (update) {
+        modalCmd.openPopupAction.shouldMatchUniqueId = true;
+        modalCmd.openPopupAction.updateAction = true;
+    }
+
+    return modalCmd;
+}
+
+function showModal(header, content, id, update) {
+    const modalCmd = Modal(header, content, id, update);
+
+    resolveCommand(modalCmd);
+}
+
+function overlayPanelItemListRenderer(items, selectedIndex) {
+    return {
+        overlayPanelItemListRenderer: {
+            items,
+            selectedIndex
+        }
+    }
+};
+
+function buttonItem(title, icon, commands) {
+    const button = {
+        compactLinkRenderer: {
+            serviceEndpoint: {
+                commandExecutorCommand: {
+                    commands
+                }
+            }
+        }
+    }
+
+    if (title) {
+        button.compactLinkRenderer.title = {
+            simpleText: title.title
+        }
+    }
+
+    if (title.subtitle) {
+        button.compactLinkRenderer.subtitle = {
+            simpleText: title.subtitle
+        }
+    }
+
+    if (icon) {
+        button.compactLinkRenderer.icon = {
+            iconType: icon.icon,
+        }
+    }
+
+    if (icon && icon.secondaryIcon) {
+        button.compactLinkRenderer.secondaryIcon = {
+            iconType: icon.secondaryIcon,
+        }
+    }
+
+    return button;
+}
+
+
+function timelyAction(text, icon, command, triggerTimeMs, timeoutMs) {
+    return {
+        timelyActionRenderer: {
+            actionButtons: [
+                {
+                    buttonRenderer: {
+                        isDisabled: false,
+                        text: {
+                            runs: [
+                                {
+                                    text: text
+                                }
+                            ]
+                        },
+                        icon: {
+                            iconType: icon
+                        },
+                        trackingParams: null,
+                        command
+                    }
+                }
+            ],
+            triggerTimeMs,
+            timeoutMs,
+            type: ''
+        }
+    }
+
+}
+
+function longPressData(data) {
+    const isWatchLaterItem = data.watchEndpointData.playlistId === 'WL';
+    const watchLaterAction = isWatchLaterItem ? {
+        removedVideoId: data.videoId,
+        action: 'ACTION_REMOVE_VIDEO_BY_VIDEO_ID'
+    } : {
+        addedVideoId: data.videoId,
+        action: 'ACTION_ADD_VIDEO'
+    };
+
+    return {
+        clickTrackingParams: null,
+        showMenuCommand: {
+            contentId: data.videoId,
+            thumbnail: {
+                thumbnails: data.thumbnails
+            },
+            title: {
+                simpleText: data.title
+            },
+            subtitle: {
+                simpleText: data.subtitle
+            },
+            menu: {
+                menuRenderer: {
+                    items: [
+                        MenuNavigationItemRenderer('Play', {
+                            clickTrackingParams: null,
+                            watchEndpoint: data.watchEndpointData
+                        }),
+                        MenuServiceItemRenderer(isWatchLaterItem ? 'Remove from Watch Later' : 'Save to Watch Later', {
+                            clickTrackingParams: null,
+                            commandMetadata: {
+                                webCommandMetadata: {
+                                    sendPost: true,
+                                    apiUrl: '/youtubei/v1/browse/edit_playlist'
+                                }
+                            },
+                            playlistEditEndpoint: {
+                                playlistId: 'WL',
+                                actions: [watchLaterAction]
+                            }
+                        }),
+                        MenuNavigationItemRenderer('Save to Playlist', {
+                            clickTrackingParams: null,
+                            addToPlaylistEndpoint: {
+                                videoId: data.videoId
+                            }
+                        }),
+                        MenuServiceItemRenderer('Add to Queue', {
+                            clickTrackingParams: null,
+                            playlistEditEndpoint: {
+                                customAction: {
+                                    action: 'ADD_TO_QUEUE',
+                                    parameters: data.item
+                                }
+                            }
+                        }),
+                        MenuServiceItemRenderer('Go To Channel', {
+                            clickTrackingParams: null,
+                            playlistEditEndpoint: {
+                                customAction: {
+                                    action: 'GO_TO_CHANNEL',
+                                    parameters: data.item
+                                }
+                            }
+                        }),
+                    ],
+                    trackingParams: null,
+                    accessibility: {
+                        accessibilityData: {
+                            label: 'Video options'
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+function MenuServiceItemRenderer(text, serviceEndpoint) {
+    return {
+        menuServiceItemRenderer: {
+            text: {
+                runs: [
+                    {
+                        text
+                    }
+                ]
+            },
+            serviceEndpoint,
+            trackingParams: null
+        }
+    };
+}
+
+function MenuNavigationItemRenderer(text, navigateEndpoint) {
+    return {
+        menuNavigationItemRenderer: {
+            text: {
+                runs: [
+                    {
+                        text
+                    }
+                ]
+            },
+            navigationEndpoint: navigateEndpoint,
+            trackingParams: null
+        }
+    }
+}
+
+function SettingsCategory(categoryId, items, title) {
+    const category = {
+        settingCategoryCollectionRenderer: {
+            items,
+            categoryId,
+            focused: false,
+            trackingParams: "null"
+        }
+    }
+
+    if (title) {
+        category.settingCategoryCollectionRenderer.title = {
+            runs: [
+                {
+                    text: title
+                }
+            ]
+        };
+    }
+
+    return category;
+}
+
+function SettingActionRenderer(title, itemId, serviceEndpoint, summary, thumbnail) {
+    return {
+        settingActionRenderer: {
+            title: {
+                runs: [
+                    {
+                        text: title
+                    }
+                ]
+            },
+            serviceEndpoint,
+            summary: {
+                runs: [
+                    {
+                        text: summary
+                    }
+                ]
+            },
+            trackingParams: "null",
+            actionLabel: {
+                runs: [
+                    {
+                        text: title
+                    }
+                ]
+            },
+            itemId,
+            thumbnail: {
+                thumbnails: [
+                    {
+                        url: thumbnail
+                    }
+                ]
+            }
+        }
+    }
+}
+
+function scrollPaneRenderer(items) {
+    return {
+        scrollPaneRenderer: {
+            content: scrollPaneItemListRenderer(items)
+        }
+    }
+}
+
+function scrollPaneItemListRenderer(items) {
+    return {
+        scrollPaneItemListRenderer: {
+            items
+        }
+    }
+}
+
+function overlayMessageRenderer(simpleText) {
+    return {
+        overlayMessageRenderer: {
+            title: {
+                simpleText
+            }
+        }
+    }
+}
+
+function ShelfRenderer(simpleText, items, selectedIndex = 0) {
+    return {
+        shelfRenderer: {
+            shelfHeaderRenderer: {
+                title: {
+                    simpleText
+                }
+            },
+            tvhtml5ShelfRendererType: "TVHTML5_SHELF_RENDERER_TYPE_GRID",
+            content: {
+                horizontalListRenderer: {
+                    items,
+                    selectedIndex,
+                    visibleItemCount: 3
+                }
+            }
+        }
+    }
+}
+
+function TileRenderer(simpleText, onSelectCommand) {
+    return {
+        tileRenderer: {
+            contentType: "TILE_CONTENT_TYPE_VIDEO",
+            metadata: {
+                tileMetadataRenderer: {
+                    title: {
+                        simpleText
+                    }
+                }
+            },
+            onSelectCommand,
+            style: "TILE_STYLE_YTLR_DEFAULT"
+        }
+    }
+}
+
+function QrCodeRenderer(url) {
+    return {
+        qrCodeRenderer: {
+            qrCodeImage: {
+                thumbnails: [
+                    {
+                        url
+                    }
+                ]
+            },
+            style: "QR_CODE_RENDERER_STYLE_ATA_SIDESHEET",
+            trackingParams: null
+        }
+    }
+}
+
+function ButtonRenderer(disabled, text, iconType, command) {
+    return {
+        isDisabled: disabled,
+        text: {
+            runs: [
+                {
+                    text: text
+                }
+            ]
+        },
+        icon: {
+            iconType
+        },
+        command: command,
+        trackingParams: null
+    };
+}
+
+function GuideEntryRenderer(simpleText, navigationEndpoint, icon, thumbnail) {
+    const guideEntryRenderer = {
+        guideEntryRenderer: {
+            navigationEndpoint,
+            trackingParams: null,
+            formattedTitle: {
+                simpleText
+            }
+        }
+    }
+
+    if (icon) {
+        guideEntryRenderer.guideEntryRenderer.icon = {
+            iconType: icon
+        }
+    }
+
+    if (thumbnail) {
+        guideEntryRenderer.guideEntryRenderer.thumbnail = {
+            thumbnails: [
+                {
+                    url: thumbnail
+                }
+            ]
+        }
+    }
+
+    return guideEntryRenderer;
+}
+
+export {
+    showToast,
+    Modal,
+    OverlayPanelHeaderRenderer,
+    showModal,
+    buttonItem,
+    overlayPanelItemListRenderer,
+    overlayMessageRenderer,
+    timelyAction,
+    scrollPaneRenderer,
+    scrollPaneItemListRenderer,
+    longPressData,
+    MenuServiceItemRenderer,
+    SettingsCategory,
+    SettingActionRenderer,
+    ShelfRenderer,
+    TileRenderer,
+    QrCodeRenderer,
+    ButtonRenderer,
+    GuideEntryRenderer
+}

package/mods/userScript.js

@@ -0,0 +1,28 @@
+import initPatches from "./features/standaloneUserscript.js";
+if (window.location.hostname === 'localhost') {
+    initPatches();
+}
+import "./features/userAgentSpoofing.js";
+import "whatwg-fetch";
+import "core-js/proposals/object-getownpropertydescriptors";
+
+import './translations/index.js'
+import "./domrect-polyfill";
+import "./features/adblock.js";
+import "./features/s95bMenu.js";
+import "./features/sponsorblock.js";
+import "./ui/ui.js";
+import "./ui/speedUI.js";
+import "./ui/theme.js";
+import "./ui/settings.js";
+import "./ui/disableWhosWatching.js";
+import "./features/moreSubtitles.js";
+import "./features/updater.js";
+import "./features/pictureInPicture.js";
+import "./features/preferredVideoQuality.js";
+import "./features/videoQueuing.js";
+import "./features/enableFeatures.js";
+import "./ui/customUI.js";
+import "./ui/customGuideAction.js";
+import "./features/autoFrameRate.js";
+import "./ui/clock.js";

package/mods/utils/ASTParser.js

@@ -0,0 +1,67 @@
+// AST Parser for TizenTube, used for finding code patterns
+// You may call me insane for this.
+
+import esprima from 'esprima';
+import estraverse from 'estraverse';
+
+// Extract assignment RHS sources and inner returned functions (IIFEs)
+export function extractAssignedFunctions(code) {
+    const original = code;
+    let wrapOffset = 0;
+    let ast;
+
+    try {
+        ast = esprima.parse(code, { range: true, tolerant: true, sourceType: 'script' });
+    } catch (e1) {
+        try {
+            const wrapped = '(' + code + ')';
+            ast = esprima.parse(wrapped, { range: true, tolerant: true, sourceType: 'script' });
+            wrapOffset = 1;
+        } catch (e2) {
+            try {
+                ast = esprima.parse(code, { range: true, tolerant: true, sourceType: 'module' });
+            } catch (e3) {
+                try {
+                    const wrapped2 = '(' + code + ')';
+                    ast = esprima.parse(wrapped2, { range: true, tolerant: true, sourceType: 'module' });
+                    wrapOffset = 1;
+                } catch (e4) {
+                    throw e1;
+                }
+            }
+        }
+    }
+
+    const out = [];
+
+    estraverse.traverse(ast, {
+        enter: function (node) {
+            if (node.type !== 'AssignmentExpression') return;
+            const rhs = node.right;
+            if (!rhs || !rhs.range) return;
+            const rhsSrc = original.slice(rhs.range[0] - wrapOffset, rhs.range[1] - wrapOffset);
+            let inner = null;
+
+            if (rhs.type === 'CallExpression' && rhs.callee && rhs.callee.type === 'FunctionExpression' && rhs.callee.body) {
+                let stm = rhs.callee.body.body || [];
+                for (let i = 0; i < stm.length; i++) {
+                    let s = stm[i];
+                    if (s.type === 'ReturnStatement' && s.argument && s.argument.range) {
+                        inner = original.slice(s.argument.range[0] - wrapOffset, s.argument.range[1] - wrapOffset);
+                        break;
+                    }
+                }
+            } else if (rhs.type === 'FunctionExpression' || rhs.type === 'ArrowFunctionExpression') {
+                inner = rhsSrc;
+            }
+
+            out.push({
+                left: node.left && node.left.range ? original.slice(node.left.range[0] - wrapOffset, node.left.range[1] - wrapOffset) : null,
+                rhs: rhsSrc,
+                returned: inner
+            });
+        }
+    });
+
+    return out;
+}